Api-roll 45: 2017-02-13

generated/googleapis/test/genomics/v1_test.dart

 library googleapis.genomics.v1.test;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart' as http_testing;
 import 'package:unittest/unittest.dart' as unittest;
@@ skipping 33 matching lines @@
     }
   }
 }
 
 http.StreamedResponse stringResponse(
     core.int status, core.Map headers, core.String body) {
   var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
   return new http.StreamedResponse(stream, status, headers: headers);
 }
 
-buildUnnamed2812() {
+buildUnnamed2906() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2812(core.List<core.Object> o) {
+checkUnnamed2906(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted1 = (o[0]) as core.Map; unittest.expect(casted1, unittest.hasLength(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], unittest.equals('foo')); 
   var casted2 = (o[1]) as core.Map; unittest.expect(casted2, unittest.hasLength(3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.expect(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2813() {
+buildUnnamed2907() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2812();
-  o["y"] = buildUnnamed2812();
+  o["x"] = buildUnnamed2906();
+  o["y"] = buildUnnamed2906();
   return o;
 }
 
-checkUnnamed2813(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2907(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2812(o["x"]);
-  checkUnnamed2812(o["y"]);
+  checkUnnamed2906(o["x"]);
+  checkUnnamed2906(o["y"]);
 }
 
 core.int buildCounterAnnotation = 0;
 buildAnnotation() {
   var o = new api.Annotation();
   buildCounterAnnotation++;
   if (buildCounterAnnotation < 3) {
     o.annotationSetId = "foo";
     o.end = "foo";
     o.id = "foo";
-    o.info = buildUnnamed2813();
+    o.info = buildUnnamed2907();
     o.name = "foo";
     o.referenceId = "foo";
     o.referenceName = "foo";
     o.reverseStrand = true;
     o.start = "foo";
     o.transcript = buildTranscript();
     o.type = "foo";
     o.variant = buildVariantAnnotation();
   }
   buildCounterAnnotation--;
   return o;
 }
 
 checkAnnotation(api.Annotation o) {
   buildCounterAnnotation++;
   if (buildCounterAnnotation < 3) {
     unittest.expect(o.annotationSetId, unittest.equals('foo'));
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2813(o.info);
+    checkUnnamed2907(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.referenceId, unittest.equals('foo'));
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.reverseStrand, unittest.isTrue);
     unittest.expect(o.start, unittest.equals('foo'));
     checkTranscript(o.transcript);
     unittest.expect(o.type, unittest.equals('foo'));
     checkVariantAnnotation(o.variant);
   }
   buildCounterAnnotation--;
 }
 
-buildUnnamed2814() {
+buildUnnamed2908() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2814(core.List<core.Object> o) {
+checkUnnamed2908(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted3 = (o[0]) as core.Map; unittest.expect(casted3, unittest.hasLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unittest.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["string"], unittest.equals('foo')); 
   var casted4 = (o[1]) as core.Map; unittest.expect(casted4, unittest.hasLength(3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.expect(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2815() {
+buildUnnamed2909() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2814();
-  o["y"] = buildUnnamed2814();
+  o["x"] = buildUnnamed2908();
+  o["y"] = buildUnnamed2908();
   return o;
 }
 
-checkUnnamed2815(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2909(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2814(o["x"]);
-  checkUnnamed2814(o["y"]);
+  checkUnnamed2908(o["x"]);
+  checkUnnamed2908(o["y"]);
 }
 
 core.int buildCounterAnnotationSet = 0;
 buildAnnotationSet() {
   var o = new api.AnnotationSet();
   buildCounterAnnotationSet++;
   if (buildCounterAnnotationSet < 3) {
     o.datasetId = "foo";
     o.id = "foo";
-    o.info = buildUnnamed2815();
+    o.info = buildUnnamed2909();
     o.name = "foo";
     o.referenceSetId = "foo";
     o.sourceUri = "foo";
     o.type = "foo";
   }
   buildCounterAnnotationSet--;
   return o;
 }
 
 checkAnnotationSet(api.AnnotationSet o) {
   buildCounterAnnotationSet++;
   if (buildCounterAnnotationSet < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2815(o.info);
+    checkUnnamed2909(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
     unittest.expect(o.sourceUri, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterAnnotationSet--;
 }
 
-buildUnnamed2816() {
+buildUnnamed2910() {
   var o = new core.List<api.Annotation>();
   o.add(buildAnnotation());
   o.add(buildAnnotation());
   return o;
 }
 
-checkUnnamed2816(core.List<api.Annotation> o) {
+checkUnnamed2910(core.List<api.Annotation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAnnotation(o[0]);
   checkAnnotation(o[1]);
 }
 
 core.int buildCounterBatchCreateAnnotationsRequest = 0;
 buildBatchCreateAnnotationsRequest() {
   var o = new api.BatchCreateAnnotationsRequest();
   buildCounterBatchCreateAnnotationsRequest++;
   if (buildCounterBatchCreateAnnotationsRequest < 3) {
-    o.annotations = buildUnnamed2816();
+    o.annotations = buildUnnamed2910();
     o.requestId = "foo";
   }
   buildCounterBatchCreateAnnotationsRequest--;
   return o;
 }
 
 checkBatchCreateAnnotationsRequest(api.BatchCreateAnnotationsRequest o) {
   buildCounterBatchCreateAnnotationsRequest++;
   if (buildCounterBatchCreateAnnotationsRequest < 3) {
-    checkUnnamed2816(o.annotations);
+    checkUnnamed2910(o.annotations);
     unittest.expect(o.requestId, unittest.equals('foo'));
   }
   buildCounterBatchCreateAnnotationsRequest--;
 }
 
-buildUnnamed2817() {
+buildUnnamed2911() {
   var o = new core.List<api.Entry>();
   o.add(buildEntry());
   o.add(buildEntry());
   return o;
 }
 
-checkUnnamed2817(core.List<api.Entry> o) {
+checkUnnamed2911(core.List<api.Entry> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkEntry(o[0]);
   checkEntry(o[1]);
 }
 
 core.int buildCounterBatchCreateAnnotationsResponse = 0;
 buildBatchCreateAnnotationsResponse() {
   var o = new api.BatchCreateAnnotationsResponse();
   buildCounterBatchCreateAnnotationsResponse++;
   if (buildCounterBatchCreateAnnotationsResponse < 3) {
-    o.entries = buildUnnamed2817();
+    o.entries = buildUnnamed2911();
   }
   buildCounterBatchCreateAnnotationsResponse--;
   return o;
 }
 
 checkBatchCreateAnnotationsResponse(api.BatchCreateAnnotationsResponse o) {
   buildCounterBatchCreateAnnotationsResponse++;
   if (buildCounterBatchCreateAnnotationsResponse < 3) {
-    checkUnnamed2817(o.entries);
+    checkUnnamed2911(o.entries);
   }
   buildCounterBatchCreateAnnotationsResponse--;
 }
 
-buildUnnamed2818() {
+buildUnnamed2912() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2818(core.List<core.String> o) {
+checkUnnamed2912(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterBinding = 0;
 buildBinding() {
   var o = new api.Binding();
   buildCounterBinding++;
   if (buildCounterBinding < 3) {
-    o.members = buildUnnamed2818();
+    o.members = buildUnnamed2912();
     o.role = "foo";
   }
   buildCounterBinding--;
   return o;
 }
 
 checkBinding(api.Binding o) {
   buildCounterBinding++;
   if (buildCounterBinding < 3) {
-    checkUnnamed2818(o.members);
+    checkUnnamed2912(o.members);
     unittest.expect(o.role, unittest.equals('foo'));
   }
   buildCounterBinding--;
 }
 
-buildUnnamed2819() {
+buildUnnamed2913() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2819(core.List<core.Object> o) {
+checkUnnamed2913(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted5 = (o[0]) as core.Map; unittest.expect(casted5, unittest.hasLength(3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expect(casted5["bool"], unittest.equals(true)); unittest.expect(casted5["string"], unittest.equals('foo')); 
   var casted6 = (o[1]) as core.Map; unittest.expect(casted6, unittest.hasLength(3)); unittest.expect(casted6["list"], unittest.equals([1, 2, 3])); unittest.expect(casted6["bool"], unittest.equals(true)); unittest.expect(casted6["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2820() {
+buildUnnamed2914() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2819();
-  o["y"] = buildUnnamed2819();
+  o["x"] = buildUnnamed2913();
+  o["y"] = buildUnnamed2913();
   return o;
 }
 
-checkUnnamed2820(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2914(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2819(o["x"]);
-  checkUnnamed2819(o["y"]);
+  checkUnnamed2913(o["x"]);
+  checkUnnamed2913(o["y"]);
 }
 
-buildUnnamed2821() {
+buildUnnamed2915() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2821(core.List<core.String> o) {
+checkUnnamed2915(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterCallSet = 0;
 buildCallSet() {
   var o = new api.CallSet();
   buildCounterCallSet++;
   if (buildCounterCallSet < 3) {
     o.created = "foo";
     o.id = "foo";
-    o.info = buildUnnamed2820();
+    o.info = buildUnnamed2914();
     o.name = "foo";
     o.sampleId = "foo";
-    o.variantSetIds = buildUnnamed2821();
+    o.variantSetIds = buildUnnamed2915();
   }
   buildCounterCallSet--;
   return o;
 }
 
 checkCallSet(api.CallSet o) {
   buildCounterCallSet++;
   if (buildCounterCallSet < 3) {
     unittest.expect(o.created, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2820(o.info);
+    checkUnnamed2914(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.sampleId, unittest.equals('foo'));
-    checkUnnamed2821(o.variantSetIds);
+    checkUnnamed2915(o.variantSetIds);
   }
   buildCounterCallSet--;
 }
 
 core.int buildCounterCancelOperationRequest = 0;
 buildCancelOperationRequest() {
   var o = new api.CancelOperationRequest();
   buildCounterCancelOperationRequest++;
   if (buildCounterCancelOperationRequest < 3) {
   }
@@ skipping 24 matching lines @@
 checkCigarUnit(api.CigarUnit o) {
   buildCounterCigarUnit++;
   if (buildCounterCigarUnit < 3) {
     unittest.expect(o.operation, unittest.equals('foo'));
     unittest.expect(o.operationLength, unittest.equals('foo'));
     unittest.expect(o.referenceSequence, unittest.equals('foo'));
   }
   buildCounterCigarUnit--;
 }
 
-buildUnnamed2822() {
+buildUnnamed2916() {
   var o = new core.List<api.ExternalId>();
   o.add(buildExternalId());
   o.add(buildExternalId());
   return o;
 }
 
-checkUnnamed2822(core.List<api.ExternalId> o) {
+checkUnnamed2916(core.List<api.ExternalId> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkExternalId(o[0]);
   checkExternalId(o[1]);
 }
 
-buildUnnamed2823() {
+buildUnnamed2917() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2823(core.List<core.String> o) {
+checkUnnamed2917(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterClinicalCondition = 0;
 buildClinicalCondition() {
   var o = new api.ClinicalCondition();
   buildCounterClinicalCondition++;
   if (buildCounterClinicalCondition < 3) {
     o.conceptId = "foo";
-    o.externalIds = buildUnnamed2822();
-    o.names = buildUnnamed2823();
+    o.externalIds = buildUnnamed2916();
+    o.names = buildUnnamed2917();
     o.omimId = "foo";
   }
   buildCounterClinicalCondition--;
   return o;
 }
 
 checkClinicalCondition(api.ClinicalCondition o) {
   buildCounterClinicalCondition++;
   if (buildCounterClinicalCondition < 3) {
     unittest.expect(o.conceptId, unittest.equals('foo'));
-    checkUnnamed2822(o.externalIds);
-    checkUnnamed2823(o.names);
+    checkUnnamed2916(o.externalIds);
+    checkUnnamed2917(o.names);
     unittest.expect(o.omimId, unittest.equals('foo'));
   }
   buildCounterClinicalCondition--;
 }
 
 core.int buildCounterCodingSequence = 0;
 buildCodingSequence() {
   var o = new api.CodingSequence();
   buildCounterCodingSequence++;
   if (buildCounterCodingSequence < 3) {
     o.end = "foo";
     o.start = "foo";
   }
   buildCounterCodingSequence--;
   return o;
 }
 
 checkCodingSequence(api.CodingSequence o) {
   buildCounterCodingSequence++;
   if (buildCounterCodingSequence < 3) {
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterCodingSequence--;
 }
 
-buildUnnamed2824() {
+buildUnnamed2918() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2824(core.List<core.String> o) {
+checkUnnamed2918(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterComputeEngine = 0;
 buildComputeEngine() {
   var o = new api.ComputeEngine();
   buildCounterComputeEngine++;
   if (buildCounterComputeEngine < 3) {
-    o.diskNames = buildUnnamed2824();
+    o.diskNames = buildUnnamed2918();
     o.instanceName = "foo";
     o.machineType = "foo";
     o.zone = "foo";
   }
   buildCounterComputeEngine--;
   return o;
 }
 
 checkComputeEngine(api.ComputeEngine o) {
   buildCounterComputeEngine++;
   if (buildCounterComputeEngine < 3) {
-    checkUnnamed2824(o.diskNames);
+    checkUnnamed2918(o.diskNames);
     unittest.expect(o.instanceName, unittest.equals('foo'));
     unittest.expect(o.machineType, unittest.equals('foo'));
     unittest.expect(o.zone, unittest.equals('foo'));
   }
   buildCounterComputeEngine--;
 }
 
 core.int buildCounterCoverageBucket = 0;
 buildCoverageBucket() {
   var o = new api.CoverageBucket();
@@ skipping 119 matching lines @@
   buildCounterExperiment++;
   if (buildCounterExperiment < 3) {
     unittest.expect(o.instrumentModel, unittest.equals('foo'));
     unittest.expect(o.libraryId, unittest.equals('foo'));
     unittest.expect(o.platformUnit, unittest.equals('foo'));
     unittest.expect(o.sequencingCenter, unittest.equals('foo'));
   }
   buildCounterExperiment--;
 }
 
-buildUnnamed2825() {
+buildUnnamed2919() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2825(core.List<core.String> o) {
+checkUnnamed2919(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterExportReadGroupSetRequest = 0;
 buildExportReadGroupSetRequest() {
   var o = new api.ExportReadGroupSetRequest();
   buildCounterExportReadGroupSetRequest++;
   if (buildCounterExportReadGroupSetRequest < 3) {
     o.exportUri = "foo";
     o.projectId = "foo";
-    o.referenceNames = buildUnnamed2825();
+    o.referenceNames = buildUnnamed2919();
   }
   buildCounterExportReadGroupSetRequest--;
   return o;
 }
 
 checkExportReadGroupSetRequest(api.ExportReadGroupSetRequest o) {
   buildCounterExportReadGroupSetRequest++;
   if (buildCounterExportReadGroupSetRequest < 3) {
     unittest.expect(o.exportUri, unittest.equals('foo'));
     unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed2825(o.referenceNames);
+    checkUnnamed2919(o.referenceNames);
   }
   buildCounterExportReadGroupSetRequest--;
 }
 
-buildUnnamed2826() {
+buildUnnamed2920() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2826(core.List<core.String> o) {
+checkUnnamed2920(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterExportVariantSetRequest = 0;
 buildExportVariantSetRequest() {
   var o = new api.ExportVariantSetRequest();
   buildCounterExportVariantSetRequest++;
   if (buildCounterExportVariantSetRequest < 3) {
     o.bigqueryDataset = "foo";
     o.bigqueryTable = "foo";
-    o.callSetIds = buildUnnamed2826();
+    o.callSetIds = buildUnnamed2920();
     o.format = "foo";
     o.projectId = "foo";
   }
   buildCounterExportVariantSetRequest--;
   return o;
 }
 
 checkExportVariantSetRequest(api.ExportVariantSetRequest o) {
   buildCounterExportVariantSetRequest++;
   if (buildCounterExportVariantSetRequest < 3) {
     unittest.expect(o.bigqueryDataset, unittest.equals('foo'));
     unittest.expect(o.bigqueryTable, unittest.equals('foo'));
-    checkUnnamed2826(o.callSetIds);
+    checkUnnamed2920(o.callSetIds);
     unittest.expect(o.format, unittest.equals('foo'));
     unittest.expect(o.projectId, unittest.equals('foo'));
   }
   buildCounterExportVariantSetRequest--;
 }
 
 core.int buildCounterExternalId = 0;
 buildExternalId() {
   var o = new api.ExternalId();
   buildCounterExternalId++;
@@ skipping 24 matching lines @@
   return o;
 }
 
 checkGetIamPolicyRequest(api.GetIamPolicyRequest o) {
   buildCounterGetIamPolicyRequest++;
   if (buildCounterGetIamPolicyRequest < 3) {
   }
   buildCounterGetIamPolicyRequest--;
 }
 
-buildUnnamed2827() {
+buildUnnamed2921() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2827(core.List<core.String> o) {
+checkUnnamed2921(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportReadGroupSetsRequest = 0;
 buildImportReadGroupSetsRequest() {
   var o = new api.ImportReadGroupSetsRequest();
   buildCounterImportReadGroupSetsRequest++;
   if (buildCounterImportReadGroupSetsRequest < 3) {
     o.datasetId = "foo";
     o.partitionStrategy = "foo";
     o.referenceSetId = "foo";
-    o.sourceUris = buildUnnamed2827();
+    o.sourceUris = buildUnnamed2921();
   }
   buildCounterImportReadGroupSetsRequest--;
   return o;
 }
 
 checkImportReadGroupSetsRequest(api.ImportReadGroupSetsRequest o) {
   buildCounterImportReadGroupSetsRequest++;
   if (buildCounterImportReadGroupSetsRequest < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.partitionStrategy, unittest.equals('foo'));
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
-    checkUnnamed2827(o.sourceUris);
+    checkUnnamed2921(o.sourceUris);
   }
   buildCounterImportReadGroupSetsRequest--;
 }
 
-buildUnnamed2828() {
+buildUnnamed2922() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2828(core.List<core.String> o) {
+checkUnnamed2922(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportReadGroupSetsResponse = 0;
 buildImportReadGroupSetsResponse() {
   var o = new api.ImportReadGroupSetsResponse();
   buildCounterImportReadGroupSetsResponse++;
   if (buildCounterImportReadGroupSetsResponse < 3) {
-    o.readGroupSetIds = buildUnnamed2828();
+    o.readGroupSetIds = buildUnnamed2922();
   }
   buildCounterImportReadGroupSetsResponse--;
   return o;
 }
 
 checkImportReadGroupSetsResponse(api.ImportReadGroupSetsResponse o) {
   buildCounterImportReadGroupSetsResponse++;
   if (buildCounterImportReadGroupSetsResponse < 3) {
-    checkUnnamed2828(o.readGroupSetIds);
+    checkUnnamed2922(o.readGroupSetIds);
   }
   buildCounterImportReadGroupSetsResponse--;
 }
 
-buildUnnamed2829() {
+buildUnnamed2923() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed2829(core.Map<core.String, core.String> o) {
+checkUnnamed2923(core.Map<core.String, core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o["x"], unittest.equals('foo'));
   unittest.expect(o["y"], unittest.equals('foo'));
 }
 
-buildUnnamed2830() {
+buildUnnamed2924() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2830(core.List<core.String> o) {
+checkUnnamed2924(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportVariantsRequest = 0;
 buildImportVariantsRequest() {
   var o = new api.ImportVariantsRequest();
   buildCounterImportVariantsRequest++;
   if (buildCounterImportVariantsRequest < 3) {
     o.format = "foo";
-    o.infoMergeConfig = buildUnnamed2829();
+    o.infoMergeConfig = buildUnnamed2923();
     o.normalizeReferenceNames = true;
-    o.sourceUris = buildUnnamed2830();
+    o.sourceUris = buildUnnamed2924();
     o.variantSetId = "foo";
   }
   buildCounterImportVariantsRequest--;
   return o;
 }
 
 checkImportVariantsRequest(api.ImportVariantsRequest o) {
   buildCounterImportVariantsRequest++;
   if (buildCounterImportVariantsRequest < 3) {
     unittest.expect(o.format, unittest.equals('foo'));
-    checkUnnamed2829(o.infoMergeConfig);
+    checkUnnamed2923(o.infoMergeConfig);
     unittest.expect(o.normalizeReferenceNames, unittest.isTrue);
-    checkUnnamed2830(o.sourceUris);
+    checkUnnamed2924(o.sourceUris);
     unittest.expect(o.variantSetId, unittest.equals('foo'));
   }
   buildCounterImportVariantsRequest--;
 }
 
-buildUnnamed2831() {
+buildUnnamed2925() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2831(core.List<core.String> o) {
+checkUnnamed2925(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportVariantsResponse = 0;
 buildImportVariantsResponse() {
   var o = new api.ImportVariantsResponse();
   buildCounterImportVariantsResponse++;
   if (buildCounterImportVariantsResponse < 3) {
-    o.callSetIds = buildUnnamed2831();
+    o.callSetIds = buildUnnamed2925();
   }
   buildCounterImportVariantsResponse--;
   return o;
 }
 
 checkImportVariantsResponse(api.ImportVariantsResponse o) {
   buildCounterImportVariantsResponse++;
   if (buildCounterImportVariantsResponse < 3) {
-    checkUnnamed2831(o.callSetIds);
+    checkUnnamed2925(o.callSetIds);
   }
   buildCounterImportVariantsResponse--;
 }
 
-buildUnnamed2832() {
+buildUnnamed2926() {
   var o = new core.List<api.CigarUnit>();
   o.add(buildCigarUnit());
   o.add(buildCigarUnit());
   return o;
 }
 
-checkUnnamed2832(core.List<api.CigarUnit> o) {
+checkUnnamed2926(core.List<api.CigarUnit> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCigarUnit(o[0]);
   checkCigarUnit(o[1]);
 }
 
 core.int buildCounterLinearAlignment = 0;
 buildLinearAlignment() {
   var o = new api.LinearAlignment();
   buildCounterLinearAlignment++;
   if (buildCounterLinearAlignment < 3) {
-    o.cigar = buildUnnamed2832();
+    o.cigar = buildUnnamed2926();
     o.mappingQuality = 42;
     o.position = buildPosition();
   }
   buildCounterLinearAlignment--;
   return o;
 }
 
 checkLinearAlignment(api.LinearAlignment o) {
   buildCounterLinearAlignment++;
   if (buildCounterLinearAlignment < 3) {
-    checkUnnamed2832(o.cigar);
+    checkUnnamed2926(o.cigar);
     unittest.expect(o.mappingQuality, unittest.equals(42));
     checkPosition(o.position);
   }
   buildCounterLinearAlignment--;
 }
 
 core.int buildCounterListBasesResponse = 0;
 buildListBasesResponse() {
   var o = new api.ListBasesResponse();
   buildCounterListBasesResponse++;
   if (buildCounterListBasesResponse < 3) {
     o.nextPageToken = "foo";
     o.offset = "foo";
     o.sequence = "foo";
   }
   buildCounterListBasesResponse--;
   return o;
 }
 
 checkListBasesResponse(api.ListBasesResponse o) {
   buildCounterListBasesResponse++;
   if (buildCounterListBasesResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.offset, unittest.equals('foo'));
     unittest.expect(o.sequence, unittest.equals('foo'));
   }
   buildCounterListBasesResponse--;
 }
 
-buildUnnamed2833() {
+buildUnnamed2927() {
   var o = new core.List<api.CoverageBucket>();
   o.add(buildCoverageBucket());
   o.add(buildCoverageBucket());
   return o;
 }
 
-checkUnnamed2833(core.List<api.CoverageBucket> o) {
+checkUnnamed2927(core.List<api.CoverageBucket> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCoverageBucket(o[0]);
   checkCoverageBucket(o[1]);
 }
 
 core.int buildCounterListCoverageBucketsResponse = 0;
 buildListCoverageBucketsResponse() {
   var o = new api.ListCoverageBucketsResponse();
   buildCounterListCoverageBucketsResponse++;
   if (buildCounterListCoverageBucketsResponse < 3) {
     o.bucketWidth = "foo";
-    o.coverageBuckets = buildUnnamed2833();
+    o.coverageBuckets = buildUnnamed2927();
     o.nextPageToken = "foo";
   }
   buildCounterListCoverageBucketsResponse--;
   return o;
 }
 
 checkListCoverageBucketsResponse(api.ListCoverageBucketsResponse o) {
   buildCounterListCoverageBucketsResponse++;
   if (buildCounterListCoverageBucketsResponse < 3) {
     unittest.expect(o.bucketWidth, unittest.equals('foo'));
-    checkUnnamed2833(o.coverageBuckets);
+    checkUnnamed2927(o.coverageBuckets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListCoverageBucketsResponse--;
 }
 
-buildUnnamed2834() {
+buildUnnamed2928() {
   var o = new core.List<api.Dataset>();
   o.add(buildDataset());
   o.add(buildDataset());
   return o;
 }
 
-checkUnnamed2834(core.List<api.Dataset> o) {
+checkUnnamed2928(core.List<api.Dataset> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDataset(o[0]);
   checkDataset(o[1]);
 }
 
 core.int buildCounterListDatasetsResponse = 0;
 buildListDatasetsResponse() {
   var o = new api.ListDatasetsResponse();
   buildCounterListDatasetsResponse++;
   if (buildCounterListDatasetsResponse < 3) {
-    o.datasets = buildUnnamed2834();
+    o.datasets = buildUnnamed2928();
     o.nextPageToken = "foo";
   }
   buildCounterListDatasetsResponse--;
   return o;
 }
 
 checkListDatasetsResponse(api.ListDatasetsResponse o) {
   buildCounterListDatasetsResponse++;
   if (buildCounterListDatasetsResponse < 3) {
-    checkUnnamed2834(o.datasets);
+    checkUnnamed2928(o.datasets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListDatasetsResponse--;
 }
 
-buildUnnamed2835() {
+buildUnnamed2929() {
   var o = new core.List<api.Operation>();
   o.add(buildOperation());
   o.add(buildOperation());
   return o;
 }
 
-checkUnnamed2835(core.List<api.Operation> o) {
+checkUnnamed2929(core.List<api.Operation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperation(o[0]);
   checkOperation(o[1]);
 }
 
 core.int buildCounterListOperationsResponse = 0;
 buildListOperationsResponse() {
   var o = new api.ListOperationsResponse();
   buildCounterListOperationsResponse++;
   if (buildCounterListOperationsResponse < 3) {
     o.nextPageToken = "foo";
-    o.operations = buildUnnamed2835();
+    o.operations = buildUnnamed2929();
   }
   buildCounterListOperationsResponse--;
   return o;
 }
 
 checkListOperationsResponse(api.ListOperationsResponse o) {
   buildCounterListOperationsResponse++;
   if (buildCounterListOperationsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed2835(o.operations);
+    checkUnnamed2929(o.operations);
   }
   buildCounterListOperationsResponse--;
 }
 
-buildUnnamed2836() {
+buildUnnamed2930() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed2836(core.Map<core.String, core.String> o) {
+checkUnnamed2930(core.Map<core.String, core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o["x"], unittest.equals('foo'));
   unittest.expect(o["y"], unittest.equals('foo'));
 }
 
-buildUnnamed2837() {
+buildUnnamed2931() {
   var o = new core.List<api.Variant>();
   o.add(buildVariant());
   o.add(buildVariant());
   return o;
 }
 
-checkUnnamed2837(core.List<api.Variant> o) {
+checkUnnamed2931(core.List<api.Variant> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariant(o[0]);
   checkVariant(o[1]);
 }
 
 core.int buildCounterMergeVariantsRequest = 0;
 buildMergeVariantsRequest() {
   var o = new api.MergeVariantsRequest();
   buildCounterMergeVariantsRequest++;
   if (buildCounterMergeVariantsRequest < 3) {
-    o.infoMergeConfig = buildUnnamed2836();
+    o.infoMergeConfig = buildUnnamed2930();
     o.variantSetId = "foo";
-    o.variants = buildUnnamed2837();
+    o.variants = buildUnnamed2931();
   }
   buildCounterMergeVariantsRequest--;
   return o;
 }
 
 checkMergeVariantsRequest(api.MergeVariantsRequest o) {
   buildCounterMergeVariantsRequest++;
   if (buildCounterMergeVariantsRequest < 3) {
-    checkUnnamed2836(o.infoMergeConfig);
+    checkUnnamed2930(o.infoMergeConfig);
     unittest.expect(o.variantSetId, unittest.equals('foo'));
-    checkUnnamed2837(o.variants);
+    checkUnnamed2931(o.variants);
   }
   buildCounterMergeVariantsRequest--;
 }
 
-buildUnnamed2838() {
+buildUnnamed2932() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed2838(core.Map<core.String, core.Object> o) {
+checkUnnamed2932(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted7 = (o["x"]) as core.Map; unittest.expect(casted7, unittest.hasLength(3)); unittest.expect(casted7["list"], unittest.equals([1, 2, 3])); unittest.expect(casted7["bool"], unittest.equals(true)); unittest.expect(casted7["string"], unittest.equals('foo')); 
   var casted8 = (o["y"]) as core.Map; unittest.expect(casted8, unittest.hasLength(3)); unittest.expect(casted8["list"], unittest.equals([1, 2, 3])); unittest.expect(casted8["bool"], unittest.equals(true)); unittest.expect(casted8["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2839() {
+buildUnnamed2933() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed2839(core.Map<core.String, core.Object> o) {
+checkUnnamed2933(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted9 = (o["x"]) as core.Map; unittest.expect(casted9, unittest.hasLength(3)); unittest.expect(casted9["list"], unittest.equals([1, 2, 3])); unittest.expect(casted9["bool"], unittest.equals(true)); unittest.expect(casted9["string"], unittest.equals('foo')); 
   var casted10 = (o["y"]) as core.Map; unittest.expect(casted10, unittest.hasLength(3)); unittest.expect(casted10["list"], unittest.equals([1, 2, 3])); unittest.expect(casted10["bool"], unittest.equals(true)); unittest.expect(casted10["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterOperation = 0;
 buildOperation() {
   var o = new api.Operation();
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     o.done = true;
     o.error = buildStatus();
-    o.metadata = buildUnnamed2838();
+    o.metadata = buildUnnamed2932();
     o.name = "foo";
-    o.response = buildUnnamed2839();
+    o.response = buildUnnamed2933();
   }
   buildCounterOperation--;
   return o;
 }
 
 checkOperation(api.Operation o) {
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     unittest.expect(o.done, unittest.isTrue);
     checkStatus(o.error);
-    checkUnnamed2838(o.metadata);
+    checkUnnamed2932(o.metadata);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed2839(o.response);
+    checkUnnamed2933(o.response);
   }
   buildCounterOperation--;
 }
 
 core.int buildCounterOperationEvent = 0;
 buildOperationEvent() {
   var o = new api.OperationEvent();
   buildCounterOperationEvent++;
   if (buildCounterOperationEvent < 3) {
     o.description = "foo";
     o.endTime = "foo";
     o.startTime = "foo";
   }
   buildCounterOperationEvent--;
   return o;
 }
 
 checkOperationEvent(api.OperationEvent o) {
   buildCounterOperationEvent++;
   if (buildCounterOperationEvent < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.endTime, unittest.equals('foo'));
     unittest.expect(o.startTime, unittest.equals('foo'));
   }
   buildCounterOperationEvent--;
 }
 
-buildUnnamed2840() {
+buildUnnamed2934() {
   var o = new core.List<api.OperationEvent>();
   o.add(buildOperationEvent());
   o.add(buildOperationEvent());
   return o;
 }
 
-checkUnnamed2840(core.List<api.OperationEvent> o) {
+checkUnnamed2934(core.List<api.OperationEvent> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationEvent(o[0]);
   checkOperationEvent(o[1]);
 }
 
-buildUnnamed2841() {
+buildUnnamed2935() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed2841(core.Map<core.String, core.String> o) {
+checkUnnamed2935(core.Map<core.String, core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o["x"], unittest.equals('foo'));
   unittest.expect(o["y"], unittest.equals('foo'));
 }
 
-buildUnnamed2842() {
+buildUnnamed2936() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed2842(core.Map<core.String, core.Object> o) {
+checkUnnamed2936(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted11 = (o["x"]) as core.Map; unittest.expect(casted11, unittest.hasLength(3)); unittest.expect(casted11["list"], unittest.equals([1, 2, 3])); unittest.expect(casted11["bool"], unittest.equals(true)); unittest.expect(casted11["string"], unittest.equals('foo')); 
   var casted12 = (o["y"]) as core.Map; unittest.expect(casted12, unittest.hasLength(3)); unittest.expect(casted12["list"], unittest.equals([1, 2, 3])); unittest.expect(casted12["bool"], unittest.equals(true)); unittest.expect(casted12["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2843() {
+buildUnnamed2937() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed2843(core.Map<core.String, core.Object> o) {
+checkUnnamed2937(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted13 = (o["x"]) as core.Map; unittest.expect(casted13, unittest.hasLength(3)); unittest.expect(casted13["list"], unittest.equals([1, 2, 3])); unittest.expect(casted13["bool"], unittest.equals(true)); unittest.expect(casted13["string"], unittest.equals('foo')); 
   var casted14 = (o["y"]) as core.Map; unittest.expect(casted14, unittest.hasLength(3)); unittest.expect(casted14["list"], unittest.equals([1, 2, 3])); unittest.expect(casted14["bool"], unittest.equals(true)); unittest.expect(casted14["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterOperationMetadata = 0;
 buildOperationMetadata() {
   var o = new api.OperationMetadata();
   buildCounterOperationMetadata++;
   if (buildCounterOperationMetadata < 3) {
     o.clientId = "foo";
     o.createTime = "foo";
     o.endTime = "foo";
-    o.events = buildUnnamed2840();
-    o.labels = buildUnnamed2841();
+    o.events = buildUnnamed2934();
+    o.labels = buildUnnamed2935();
     o.projectId = "foo";
-    o.request = buildUnnamed2842();
-    o.runtimeMetadata = buildUnnamed2843();
+    o.request = buildUnnamed2936();
+    o.runtimeMetadata = buildUnnamed2937();
     o.startTime = "foo";
   }
   buildCounterOperationMetadata--;
   return o;
 }
 
 checkOperationMetadata(api.OperationMetadata o) {
   buildCounterOperationMetadata++;
   if (buildCounterOperationMetadata < 3) {
     unittest.expect(o.clientId, unittest.equals('foo'));
     unittest.expect(o.createTime, unittest.equals('foo'));
     unittest.expect(o.endTime, unittest.equals('foo'));
-    checkUnnamed2840(o.events);
-    checkUnnamed2841(o.labels);
+    checkUnnamed2934(o.events);
+    checkUnnamed2935(o.labels);
     unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed2842(o.request);
-    checkUnnamed2843(o.runtimeMetadata);
+    checkUnnamed2936(o.request);
+    checkUnnamed2937(o.runtimeMetadata);
     unittest.expect(o.startTime, unittest.equals('foo'));
   }
   buildCounterOperationMetadata--;
 }
 
-buildUnnamed2844() {
+buildUnnamed2938() {
   var o = new core.List<api.Binding>();
   o.add(buildBinding());
   o.add(buildBinding());
   return o;
 }
 
-checkUnnamed2844(core.List<api.Binding> o) {
+checkUnnamed2938(core.List<api.Binding> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkBinding(o[0]);
   checkBinding(o[1]);
 }
 
 core.int buildCounterPolicy = 0;
 buildPolicy() {
   var o = new api.Policy();
   buildCounterPolicy++;
   if (buildCounterPolicy < 3) {
-    o.bindings = buildUnnamed2844();
+    o.bindings = buildUnnamed2938();
     o.etag = "foo";
     o.version = 42;
   }
   buildCounterPolicy--;
   return o;
 }
 
 checkPolicy(api.Policy o) {
   buildCounterPolicy++;
   if (buildCounterPolicy < 3) {
-    checkUnnamed2844(o.bindings);
+    checkUnnamed2938(o.bindings);
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.version, unittest.equals(42));
   }
   buildCounterPolicy--;
 }
 
 core.int buildCounterPosition = 0;
 buildPosition() {
   var o = new api.Position();
   buildCounterPosition++;
@@ skipping 59 matching lines @@
 checkRange(api.Range o) {
   buildCounterRange++;
   if (buildCounterRange < 3) {
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterRange--;
 }
 
-buildUnnamed2845() {
+buildUnnamed2939() {
   var o = new core.List<core.int>();
   o.add(42);
   o.add(42);
   return o;
 }
 
-checkUnnamed2845(core.List<core.int> o) {
+checkUnnamed2939(core.List<core.int> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals(42));
   unittest.expect(o[1], unittest.equals(42));
 }
 
-buildUnnamed2846() {
+buildUnnamed2940() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2846(core.List<core.Object> o) {
+checkUnnamed2940(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted15 = (o[0]) as core.Map; unittest.expect(casted15, unittest.hasLength(3)); unittest.expect(casted15["list"], unittest.equals([1, 2, 3])); unittest.expect(casted15["bool"], unittest.equals(true)); unittest.expect(casted15["string"], unittest.equals('foo')); 
   var casted16 = (o[1]) as core.Map; unittest.expect(casted16, unittest.hasLength(3)); unittest.expect(casted16["list"], unittest.equals([1, 2, 3])); unittest.expect(casted16["bool"], unittest.equals(true)); unittest.expect(casted16["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2847() {
+buildUnnamed2941() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2846();
-  o["y"] = buildUnnamed2846();
+  o["x"] = buildUnnamed2940();
+  o["y"] = buildUnnamed2940();
   return o;
 }
 
-checkUnnamed2847(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2941(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2846(o["x"]);
-  checkUnnamed2846(o["y"]);
+  checkUnnamed2940(o["x"]);
+  checkUnnamed2940(o["y"]);
 }
 
 core.int buildCounterRead = 0;
 buildRead() {
   var o = new api.Read();
   buildCounterRead++;
   if (buildCounterRead < 3) {
-    o.alignedQuality = buildUnnamed2845();
+    o.alignedQuality = buildUnnamed2939();
     o.alignedSequence = "foo";
     o.alignment = buildLinearAlignment();
     o.duplicateFragment = true;
     o.failedVendorQualityChecks = true;
     o.fragmentLength = 42;
     o.fragmentName = "foo";
     o.id = "foo";
-    o.info = buildUnnamed2847();
+    o.info = buildUnnamed2941();
     o.nextMatePosition = buildPosition();
     o.numberReads = 42;
     o.properPlacement = true;
     o.readGroupId = "foo";
     o.readGroupSetId = "foo";
     o.readNumber = 42;
     o.secondaryAlignment = true;
     o.supplementaryAlignment = true;
   }
   buildCounterRead--;
   return o;
 }
 
 checkRead(api.Read o) {
   buildCounterRead++;
   if (buildCounterRead < 3) {
-    checkUnnamed2845(o.alignedQuality);
+    checkUnnamed2939(o.alignedQuality);
     unittest.expect(o.alignedSequence, unittest.equals('foo'));
     checkLinearAlignment(o.alignment);
     unittest.expect(o.duplicateFragment, unittest.isTrue);
     unittest.expect(o.failedVendorQualityChecks, unittest.isTrue);
     unittest.expect(o.fragmentLength, unittest.equals(42));
     unittest.expect(o.fragmentName, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2847(o.info);
+    checkUnnamed2941(o.info);
     checkPosition(o.nextMatePosition);
     unittest.expect(o.numberReads, unittest.equals(42));
     unittest.expect(o.properPlacement, unittest.isTrue);
     unittest.expect(o.readGroupId, unittest.equals('foo'));
     unittest.expect(o.readGroupSetId, unittest.equals('foo'));
     unittest.expect(o.readNumber, unittest.equals(42));
     unittest.expect(o.secondaryAlignment, unittest.isTrue);
     unittest.expect(o.supplementaryAlignment, unittest.isTrue);
   }
   buildCounterRead--;
 }
 
-buildUnnamed2848() {
+buildUnnamed2942() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2848(core.List<core.Object> o) {
+checkUnnamed2942(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted17 = (o[0]) as core.Map; unittest.expect(casted17, unittest.hasLength(3)); unittest.expect(casted17["list"], unittest.equals([1, 2, 3])); unittest.expect(casted17["bool"], unittest.equals(true)); unittest.expect(casted17["string"], unittest.equals('foo')); 
   var casted18 = (o[1]) as core.Map; unittest.expect(casted18, unittest.hasLength(3)); unittest.expect(casted18["list"], unittest.equals([1, 2, 3])); unittest.expect(casted18["bool"], unittest.equals(true)); unittest.expect(casted18["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2849() {
+buildUnnamed2943() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2848();
-  o["y"] = buildUnnamed2848();
+  o["x"] = buildUnnamed2942();
+  o["y"] = buildUnnamed2942();
   return o;
 }
 
-checkUnnamed2849(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2943(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2848(o["x"]);
-  checkUnnamed2848(o["y"]);
+  checkUnnamed2942(o["x"]);
+  checkUnnamed2942(o["y"]);
 }
 
-buildUnnamed2850() {
+buildUnnamed2944() {
   var o = new core.List<api.Program>();
   o.add(buildProgram());
   o.add(buildProgram());
   return o;
 }
 
-checkUnnamed2850(core.List<api.Program> o) {
+checkUnnamed2944(core.List<api.Program> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkProgram(o[0]);
   checkProgram(o[1]);
 }
 
 core.int buildCounterReadGroup = 0;
 buildReadGroup() {
   var o = new api.ReadGroup();
   buildCounterReadGroup++;
   if (buildCounterReadGroup < 3) {
     o.datasetId = "foo";
     o.description = "foo";
     o.experiment = buildExperiment();
     o.id = "foo";
-    o.info = buildUnnamed2849();
+    o.info = buildUnnamed2943();
     o.name = "foo";
     o.predictedInsertSize = 42;
-    o.programs = buildUnnamed2850();
+    o.programs = buildUnnamed2944();
     o.referenceSetId = "foo";
     o.sampleId = "foo";
   }
   buildCounterReadGroup--;
   return o;
 }
 
 checkReadGroup(api.ReadGroup o) {
   buildCounterReadGroup++;
   if (buildCounterReadGroup < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     checkExperiment(o.experiment);
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2849(o.info);
+    checkUnnamed2943(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.predictedInsertSize, unittest.equals(42));
-    checkUnnamed2850(o.programs);
+    checkUnnamed2944(o.programs);
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
     unittest.expect(o.sampleId, unittest.equals('foo'));
   }
   buildCounterReadGroup--;
 }
 
-buildUnnamed2851() {
+buildUnnamed2945() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2851(core.List<core.Object> o) {
+checkUnnamed2945(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted19 = (o[0]) as core.Map; unittest.expect(casted19, unittest.hasLength(3)); unittest.expect(casted19["list"], unittest.equals([1, 2, 3])); unittest.expect(casted19["bool"], unittest.equals(true)); unittest.expect(casted19["string"], unittest.equals('foo')); 
   var casted20 = (o[1]) as core.Map; unittest.expect(casted20, unittest.hasLength(3)); unittest.expect(casted20["list"], unittest.equals([1, 2, 3])); unittest.expect(casted20["bool"], unittest.equals(true)); unittest.expect(casted20["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2852() {
+buildUnnamed2946() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2851();
-  o["y"] = buildUnnamed2851();
+  o["x"] = buildUnnamed2945();
+  o["y"] = buildUnnamed2945();
   return o;
 }
 
-checkUnnamed2852(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2946(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2851(o["x"]);
-  checkUnnamed2851(o["y"]);
+  checkUnnamed2945(o["x"]);
+  checkUnnamed2945(o["y"]);
 }
 
-buildUnnamed2853() {
+buildUnnamed2947() {
   var o = new core.List<api.ReadGroup>();
   o.add(buildReadGroup());
   o.add(buildReadGroup());
   return o;
 }
 
-checkUnnamed2853(core.List<api.ReadGroup> o) {
+checkUnnamed2947(core.List<api.ReadGroup> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkReadGroup(o[0]);
   checkReadGroup(o[1]);
 }
 
 core.int buildCounterReadGroupSet = 0;
 buildReadGroupSet() {
   var o = new api.ReadGroupSet();
   buildCounterReadGroupSet++;
   if (buildCounterReadGroupSet < 3) {
     o.datasetId = "foo";
     o.filename = "foo";
     o.id = "foo";
-    o.info = buildUnnamed2852();
+    o.info = buildUnnamed2946();
     o.name = "foo";
-    o.readGroups = buildUnnamed2853();
+    o.readGroups = buildUnnamed2947();
     o.referenceSetId = "foo";
   }
   buildCounterReadGroupSet--;
   return o;
 }
 
 checkReadGroupSet(api.ReadGroupSet o) {
   buildCounterReadGroupSet++;
   if (buildCounterReadGroupSet < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.filename, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2852(o.info);
+    checkUnnamed2946(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed2853(o.readGroups);
+    checkUnnamed2947(o.readGroups);
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
   }
   buildCounterReadGroupSet--;
 }
 
-buildUnnamed2854() {
+buildUnnamed2948() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2854(core.List<core.String> o) {
+checkUnnamed2948(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterReference = 0;
 buildReference() {
   var o = new api.Reference();
   buildCounterReference++;
   if (buildCounterReference < 3) {
     o.id = "foo";
     o.length = "foo";
     o.md5checksum = "foo";
     o.name = "foo";
     o.ncbiTaxonId = 42;
-    o.sourceAccessions = buildUnnamed2854();
+    o.sourceAccessions = buildUnnamed2948();
     o.sourceUri = "foo";
   }
   buildCounterReference--;
   return o;
 }
 
 checkReference(api.Reference o) {
   buildCounterReference++;
   if (buildCounterReference < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.length, unittest.equals('foo'));
     unittest.expect(o.md5checksum, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.ncbiTaxonId, unittest.equals(42));
-    checkUnnamed2854(o.sourceAccessions);
+    checkUnnamed2948(o.sourceAccessions);
     unittest.expect(o.sourceUri, unittest.equals('foo'));
   }
   buildCounterReference--;
 }
 
 core.int buildCounterReferenceBound = 0;
 buildReferenceBound() {
   var o = new api.ReferenceBound();
   buildCounterReferenceBound++;
   if (buildCounterReferenceBound < 3) {
     o.referenceName = "foo";
     o.upperBound = "foo";
   }
   buildCounterReferenceBound--;
   return o;
 }
 
 checkReferenceBound(api.ReferenceBound o) {
   buildCounterReferenceBound++;
   if (buildCounterReferenceBound < 3) {
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.upperBound, unittest.equals('foo'));
   }
   buildCounterReferenceBound--;
 }
 
-buildUnnamed2855() {
+buildUnnamed2949() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2855(core.List<core.String> o) {
+checkUnnamed2949(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2856() {
+buildUnnamed2950() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2856(core.List<core.String> o) {
+checkUnnamed2950(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterReferenceSet = 0;
 buildReferenceSet() {
   var o = new api.ReferenceSet();
   buildCounterReferenceSet++;
   if (buildCounterReferenceSet < 3) {
     o.assemblyId = "foo";
     o.description = "foo";
     o.id = "foo";
     o.md5checksum = "foo";
     o.ncbiTaxonId = 42;
-    o.referenceIds = buildUnnamed2855();
-    o.sourceAccessions = buildUnnamed2856();
+    o.referenceIds = buildUnnamed2949();
+    o.sourceAccessions = buildUnnamed2950();
     o.sourceUri = "foo";
   }
   buildCounterReferenceSet--;
   return o;
 }
 
 checkReferenceSet(api.ReferenceSet o) {
   buildCounterReferenceSet++;
   if (buildCounterReferenceSet < 3) {
     unittest.expect(o.assemblyId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.md5checksum, unittest.equals('foo'));
     unittest.expect(o.ncbiTaxonId, unittest.equals(42));
-    checkUnnamed2855(o.referenceIds);
-    checkUnnamed2856(o.sourceAccessions);
+    checkUnnamed2949(o.referenceIds);
+    checkUnnamed2950(o.sourceAccessions);
     unittest.expect(o.sourceUri, unittest.equals('foo'));
   }
   buildCounterReferenceSet--;
 }
 
 core.int buildCounterRuntimeMetadata = 0;
 buildRuntimeMetadata() {
   var o = new api.RuntimeMetadata();
   buildCounterRuntimeMetadata++;
   if (buildCounterRuntimeMetadata < 3) {
     o.computeEngine = buildComputeEngine();
   }
   buildCounterRuntimeMetadata--;
   return o;
 }
 
 checkRuntimeMetadata(api.RuntimeMetadata o) {
   buildCounterRuntimeMetadata++;
   if (buildCounterRuntimeMetadata < 3) {
     checkComputeEngine(o.computeEngine);
   }
   buildCounterRuntimeMetadata--;
 }
 
-buildUnnamed2857() {
+buildUnnamed2951() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2857(core.List<core.String> o) {
+checkUnnamed2951(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2858() {
+buildUnnamed2952() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2858(core.List<core.String> o) {
+checkUnnamed2952(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchAnnotationSetsRequest = 0;
 buildSearchAnnotationSetsRequest() {
   var o = new api.SearchAnnotationSetsRequest();
   buildCounterSearchAnnotationSetsRequest++;
   if (buildCounterSearchAnnotationSetsRequest < 3) {
-    o.datasetIds = buildUnnamed2857();
+    o.datasetIds = buildUnnamed2951();
     o.name = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceSetId = "foo";
-    o.types = buildUnnamed2858();
+    o.types = buildUnnamed2952();
   }
   buildCounterSearchAnnotationSetsRequest--;
   return o;
 }
 
 checkSearchAnnotationSetsRequest(api.SearchAnnotationSetsRequest o) {
   buildCounterSearchAnnotationSetsRequest++;
   if (buildCounterSearchAnnotationSetsRequest < 3) {
-    checkUnnamed2857(o.datasetIds);
+    checkUnnamed2951(o.datasetIds);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
-    checkUnnamed2858(o.types);
+    checkUnnamed2952(o.types);
   }
   buildCounterSearchAnnotationSetsRequest--;
 }
 
-buildUnnamed2859() {
+buildUnnamed2953() {
   var o = new core.List<api.AnnotationSet>();
   o.add(buildAnnotationSet());
   o.add(buildAnnotationSet());
   return o;
 }
 
-checkUnnamed2859(core.List<api.AnnotationSet> o) {
+checkUnnamed2953(core.List<api.AnnotationSet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAnnotationSet(o[0]);
   checkAnnotationSet(o[1]);
 }
 
 core.int buildCounterSearchAnnotationSetsResponse = 0;
 buildSearchAnnotationSetsResponse() {
   var o = new api.SearchAnnotationSetsResponse();
   buildCounterSearchAnnotationSetsResponse++;
   if (buildCounterSearchAnnotationSetsResponse < 3) {
-    o.annotationSets = buildUnnamed2859();
+    o.annotationSets = buildUnnamed2953();
     o.nextPageToken = "foo";
   }
   buildCounterSearchAnnotationSetsResponse--;
   return o;
 }
 
 checkSearchAnnotationSetsResponse(api.SearchAnnotationSetsResponse o) {
   buildCounterSearchAnnotationSetsResponse++;
   if (buildCounterSearchAnnotationSetsResponse < 3) {
-    checkUnnamed2859(o.annotationSets);
+    checkUnnamed2953(o.annotationSets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchAnnotationSetsResponse--;
 }
 
-buildUnnamed2860() {
+buildUnnamed2954() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2860(core.List<core.String> o) {
+checkUnnamed2954(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchAnnotationsRequest = 0;
 buildSearchAnnotationsRequest() {
   var o = new api.SearchAnnotationsRequest();
   buildCounterSearchAnnotationsRequest++;
   if (buildCounterSearchAnnotationsRequest < 3) {
-    o.annotationSetIds = buildUnnamed2860();
+    o.annotationSetIds = buildUnnamed2954();
     o.end = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceId = "foo";
     o.referenceName = "foo";
     o.start = "foo";
   }
   buildCounterSearchAnnotationsRequest--;
   return o;
 }
 
 checkSearchAnnotationsRequest(api.SearchAnnotationsRequest o) {
   buildCounterSearchAnnotationsRequest++;
   if (buildCounterSearchAnnotationsRequest < 3) {
-    checkUnnamed2860(o.annotationSetIds);
+    checkUnnamed2954(o.annotationSetIds);
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
     unittest.expect(o.referenceId, unittest.equals('foo'));
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterSearchAnnotationsRequest--;
 }
 
-buildUnnamed2861() {
+buildUnnamed2955() {
   var o = new core.List<api.Annotation>();
   o.add(buildAnnotation());
   o.add(buildAnnotation());
   return o;
 }
 
-checkUnnamed2861(core.List<api.Annotation> o) {
+checkUnnamed2955(core.List<api.Annotation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAnnotation(o[0]);
   checkAnnotation(o[1]);
 }
 
 core.int buildCounterSearchAnnotationsResponse = 0;
 buildSearchAnnotationsResponse() {
   var o = new api.SearchAnnotationsResponse();
   buildCounterSearchAnnotationsResponse++;
   if (buildCounterSearchAnnotationsResponse < 3) {
-    o.annotations = buildUnnamed2861();
+    o.annotations = buildUnnamed2955();
     o.nextPageToken = "foo";
   }
   buildCounterSearchAnnotationsResponse--;
   return o;
 }
 
 checkSearchAnnotationsResponse(api.SearchAnnotationsResponse o) {
   buildCounterSearchAnnotationsResponse++;
   if (buildCounterSearchAnnotationsResponse < 3) {
-    checkUnnamed2861(o.annotations);
+    checkUnnamed2955(o.annotations);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchAnnotationsResponse--;
 }
 
-buildUnnamed2862() {
+buildUnnamed2956() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2862(core.List<core.String> o) {
+checkUnnamed2956(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchCallSetsRequest = 0;
 buildSearchCallSetsRequest() {
   var o = new api.SearchCallSetsRequest();
   buildCounterSearchCallSetsRequest++;
   if (buildCounterSearchCallSetsRequest < 3) {
     o.name = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
-    o.variantSetIds = buildUnnamed2862();
+    o.variantSetIds = buildUnnamed2956();
   }
   buildCounterSearchCallSetsRequest--;
   return o;
 }
 
 checkSearchCallSetsRequest(api.SearchCallSetsRequest o) {
   buildCounterSearchCallSetsRequest++;
   if (buildCounterSearchCallSetsRequest < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
-    checkUnnamed2862(o.variantSetIds);
+    checkUnnamed2956(o.variantSetIds);
   }
   buildCounterSearchCallSetsRequest--;
 }
 
-buildUnnamed2863() {
+buildUnnamed2957() {
   var o = new core.List<api.CallSet>();
   o.add(buildCallSet());
   o.add(buildCallSet());
   return o;
 }
 
-checkUnnamed2863(core.List<api.CallSet> o) {
+checkUnnamed2957(core.List<api.CallSet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCallSet(o[0]);
   checkCallSet(o[1]);
 }
 
 core.int buildCounterSearchCallSetsResponse = 0;
 buildSearchCallSetsResponse() {
   var o = new api.SearchCallSetsResponse();
   buildCounterSearchCallSetsResponse++;
   if (buildCounterSearchCallSetsResponse < 3) {
-    o.callSets = buildUnnamed2863();
+    o.callSets = buildUnnamed2957();
     o.nextPageToken = "foo";
   }
   buildCounterSearchCallSetsResponse--;
   return o;
 }
 
 checkSearchCallSetsResponse(api.SearchCallSetsResponse o) {
   buildCounterSearchCallSetsResponse++;
   if (buildCounterSearchCallSetsResponse < 3) {
-    checkUnnamed2863(o.callSets);
+    checkUnnamed2957(o.callSets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchCallSetsResponse--;
 }
 
-buildUnnamed2864() {
+buildUnnamed2958() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2864(core.List<core.String> o) {
+checkUnnamed2958(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchReadGroupSetsRequest = 0;
 buildSearchReadGroupSetsRequest() {
   var o = new api.SearchReadGroupSetsRequest();
   buildCounterSearchReadGroupSetsRequest++;
   if (buildCounterSearchReadGroupSetsRequest < 3) {
-    o.datasetIds = buildUnnamed2864();
+    o.datasetIds = buildUnnamed2958();
     o.name = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchReadGroupSetsRequest--;
   return o;
 }
 
 checkSearchReadGroupSetsRequest(api.SearchReadGroupSetsRequest o) {
   buildCounterSearchReadGroupSetsRequest++;
   if (buildCounterSearchReadGroupSetsRequest < 3) {
-    checkUnnamed2864(o.datasetIds);
+    checkUnnamed2958(o.datasetIds);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchReadGroupSetsRequest--;
 }
 
-buildUnnamed2865() {
+buildUnnamed2959() {
   var o = new core.List<api.ReadGroupSet>();
   o.add(buildReadGroupSet());
   o.add(buildReadGroupSet());
   return o;
 }
 
-checkUnnamed2865(core.List<api.ReadGroupSet> o) {
+checkUnnamed2959(core.List<api.ReadGroupSet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkReadGroupSet(o[0]);
   checkReadGroupSet(o[1]);
 }
 
 core.int buildCounterSearchReadGroupSetsResponse = 0;
 buildSearchReadGroupSetsResponse() {
   var o = new api.SearchReadGroupSetsResponse();
   buildCounterSearchReadGroupSetsResponse++;
   if (buildCounterSearchReadGroupSetsResponse < 3) {
     o.nextPageToken = "foo";
-    o.readGroupSets = buildUnnamed2865();
+    o.readGroupSets = buildUnnamed2959();
   }
   buildCounterSearchReadGroupSetsResponse--;
   return o;
 }
 
 checkSearchReadGroupSetsResponse(api.SearchReadGroupSetsResponse o) {
   buildCounterSearchReadGroupSetsResponse++;
   if (buildCounterSearchReadGroupSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed2865(o.readGroupSets);
+    checkUnnamed2959(o.readGroupSets);
   }
   buildCounterSearchReadGroupSetsResponse--;
 }
 
-buildUnnamed2866() {
+buildUnnamed2960() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2866(core.List<core.String> o) {
+checkUnnamed2960(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2867() {
+buildUnnamed2961() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2867(core.List<core.String> o) {
+checkUnnamed2961(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchReadsRequest = 0;
 buildSearchReadsRequest() {
   var o = new api.SearchReadsRequest();
   buildCounterSearchReadsRequest++;
   if (buildCounterSearchReadsRequest < 3) {
     o.end = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
-    o.readGroupIds = buildUnnamed2866();
-    o.readGroupSetIds = buildUnnamed2867();
+    o.readGroupIds = buildUnnamed2960();
+    o.readGroupSetIds = buildUnnamed2961();
     o.referenceName = "foo";
     o.start = "foo";
   }
   buildCounterSearchReadsRequest--;
   return o;
 }
 
 checkSearchReadsRequest(api.SearchReadsRequest o) {
   buildCounterSearchReadsRequest++;
   if (buildCounterSearchReadsRequest < 3) {
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
-    checkUnnamed2866(o.readGroupIds);
-    checkUnnamed2867(o.readGroupSetIds);
+    checkUnnamed2960(o.readGroupIds);
+    checkUnnamed2961(o.readGroupSetIds);
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterSearchReadsRequest--;
 }
 
-buildUnnamed2868() {
+buildUnnamed2962() {
   var o = new core.List<api.Read>();
   o.add(buildRead());
   o.add(buildRead());
   return o;
 }
 
-checkUnnamed2868(core.List<api.Read> o) {
+checkUnnamed2962(core.List<api.Read> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkRead(o[0]);
   checkRead(o[1]);
 }
 
 core.int buildCounterSearchReadsResponse = 0;
 buildSearchReadsResponse() {
   var o = new api.SearchReadsResponse();
   buildCounterSearchReadsResponse++;
   if (buildCounterSearchReadsResponse < 3) {
-    o.alignments = buildUnnamed2868();
+    o.alignments = buildUnnamed2962();
     o.nextPageToken = "foo";
   }
   buildCounterSearchReadsResponse--;
   return o;
 }
 
 checkSearchReadsResponse(api.SearchReadsResponse o) {
   buildCounterSearchReadsResponse++;
   if (buildCounterSearchReadsResponse < 3) {
-    checkUnnamed2868(o.alignments);
+    checkUnnamed2962(o.alignments);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchReadsResponse--;
 }
 
-buildUnnamed2869() {
+buildUnnamed2963() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2869(core.List<core.String> o) {
+checkUnnamed2963(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2870() {
+buildUnnamed2964() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2870(core.List<core.String> o) {
+checkUnnamed2964(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchReferenceSetsRequest = 0;
 buildSearchReferenceSetsRequest() {
   var o = new api.SearchReferenceSetsRequest();
   buildCounterSearchReferenceSetsRequest++;
   if (buildCounterSearchReferenceSetsRequest < 3) {
-    o.accessions = buildUnnamed2869();
+    o.accessions = buildUnnamed2963();
     o.assemblyId = "foo";
-    o.md5checksums = buildUnnamed2870();
+    o.md5checksums = buildUnnamed2964();
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchReferenceSetsRequest--;
   return o;
 }
 
 checkSearchReferenceSetsRequest(api.SearchReferenceSetsRequest o) {
   buildCounterSearchReferenceSetsRequest++;
   if (buildCounterSearchReferenceSetsRequest < 3) {
-    checkUnnamed2869(o.accessions);
+    checkUnnamed2963(o.accessions);
     unittest.expect(o.assemblyId, unittest.equals('foo'));
-    checkUnnamed2870(o.md5checksums);
+    checkUnnamed2964(o.md5checksums);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchReferenceSetsRequest--;
 }
 
-buildUnnamed2871() {
+buildUnnamed2965() {
   var o = new core.List<api.ReferenceSet>();
   o.add(buildReferenceSet());
   o.add(buildReferenceSet());
   return o;
 }
 
-checkUnnamed2871(core.List<api.ReferenceSet> o) {
+checkUnnamed2965(core.List<api.ReferenceSet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkReferenceSet(o[0]);
   checkReferenceSet(o[1]);
 }
 
 core.int buildCounterSearchReferenceSetsResponse = 0;
 buildSearchReferenceSetsResponse() {
   var o = new api.SearchReferenceSetsResponse();
   buildCounterSearchReferenceSetsResponse++;
   if (buildCounterSearchReferenceSetsResponse < 3) {
     o.nextPageToken = "foo";
-    o.referenceSets = buildUnnamed2871();
+    o.referenceSets = buildUnnamed2965();
   }
   buildCounterSearchReferenceSetsResponse--;
   return o;
 }
 
 checkSearchReferenceSetsResponse(api.SearchReferenceSetsResponse o) {
   buildCounterSearchReferenceSetsResponse++;
   if (buildCounterSearchReferenceSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed2871(o.referenceSets);
+    checkUnnamed2965(o.referenceSets);
   }
   buildCounterSearchReferenceSetsResponse--;
 }
 
-buildUnnamed2872() {
+buildUnnamed2966() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2872(core.List<core.String> o) {
+checkUnnamed2966(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2873() {
+buildUnnamed2967() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2873(core.List<core.String> o) {
+checkUnnamed2967(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchReferencesRequest = 0;
 buildSearchReferencesRequest() {
   var o = new api.SearchReferencesRequest();
   buildCounterSearchReferencesRequest++;
   if (buildCounterSearchReferencesRequest < 3) {
-    o.accessions = buildUnnamed2872();
-    o.md5checksums = buildUnnamed2873();
+    o.accessions = buildUnnamed2966();
+    o.md5checksums = buildUnnamed2967();
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceSetId = "foo";
   }
   buildCounterSearchReferencesRequest--;
   return o;
 }
 
 checkSearchReferencesRequest(api.SearchReferencesRequest o) {
   buildCounterSearchReferencesRequest++;
   if (buildCounterSearchReferencesRequest < 3) {
-    checkUnnamed2872(o.accessions);
-    checkUnnamed2873(o.md5checksums);
+    checkUnnamed2966(o.accessions);
+    checkUnnamed2967(o.md5checksums);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
   }
   buildCounterSearchReferencesRequest--;
 }
 
-buildUnnamed2874() {
+buildUnnamed2968() {
   var o = new core.List<api.Reference>();
   o.add(buildReference());
   o.add(buildReference());
   return o;
 }
 
-checkUnnamed2874(core.List<api.Reference> o) {
+checkUnnamed2968(core.List<api.Reference> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkReference(o[0]);
   checkReference(o[1]);
 }
 
 core.int buildCounterSearchReferencesResponse = 0;
 buildSearchReferencesResponse() {
   var o = new api.SearchReferencesResponse();
   buildCounterSearchReferencesResponse++;
   if (buildCounterSearchReferencesResponse < 3) {
     o.nextPageToken = "foo";
-    o.references = buildUnnamed2874();
+    o.references = buildUnnamed2968();
   }
   buildCounterSearchReferencesResponse--;
   return o;
 }
 
 checkSearchReferencesResponse(api.SearchReferencesResponse o) {
   buildCounterSearchReferencesResponse++;
   if (buildCounterSearchReferencesResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed2874(o.references);
+    checkUnnamed2968(o.references);
   }
   buildCounterSearchReferencesResponse--;
 }
 
-buildUnnamed2875() {
+buildUnnamed2969() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2875(core.List<core.String> o) {
+checkUnnamed2969(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchVariantSetsRequest = 0;
 buildSearchVariantSetsRequest() {
   var o = new api.SearchVariantSetsRequest();
   buildCounterSearchVariantSetsRequest++;
   if (buildCounterSearchVariantSetsRequest < 3) {
-    o.datasetIds = buildUnnamed2875();
+    o.datasetIds = buildUnnamed2969();
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchVariantSetsRequest--;
   return o;
 }
 
 checkSearchVariantSetsRequest(api.SearchVariantSetsRequest o) {
   buildCounterSearchVariantSetsRequest++;
   if (buildCounterSearchVariantSetsRequest < 3) {
-    checkUnnamed2875(o.datasetIds);
+    checkUnnamed2969(o.datasetIds);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchVariantSetsRequest--;
 }
 
-buildUnnamed2876() {
+buildUnnamed2970() {
   var o = new core.List<api.VariantSet>();
   o.add(buildVariantSet());
   o.add(buildVariantSet());
   return o;
 }
 
-checkUnnamed2876(core.List<api.VariantSet> o) {
+checkUnnamed2970(core.List<api.VariantSet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariantSet(o[0]);
   checkVariantSet(o[1]);
 }
 
 core.int buildCounterSearchVariantSetsResponse = 0;
 buildSearchVariantSetsResponse() {
   var o = new api.SearchVariantSetsResponse();
   buildCounterSearchVariantSetsResponse++;
   if (buildCounterSearchVariantSetsResponse < 3) {
     o.nextPageToken = "foo";
-    o.variantSets = buildUnnamed2876();
+    o.variantSets = buildUnnamed2970();
   }
   buildCounterSearchVariantSetsResponse--;
   return o;
 }
 
 checkSearchVariantSetsResponse(api.SearchVariantSetsResponse o) {
   buildCounterSearchVariantSetsResponse++;
   if (buildCounterSearchVariantSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed2876(o.variantSets);
+    checkUnnamed2970(o.variantSets);
   }
   buildCounterSearchVariantSetsResponse--;
 }
 
-buildUnnamed2877() {
+buildUnnamed2971() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2877(core.List<core.String> o) {
+checkUnnamed2971(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2878() {
+buildUnnamed2972() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2878(core.List<core.String> o) {
+checkUnnamed2972(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchVariantsRequest = 0;
 buildSearchVariantsRequest() {
   var o = new api.SearchVariantsRequest();
   buildCounterSearchVariantsRequest++;
   if (buildCounterSearchVariantsRequest < 3) {
-    o.callSetIds = buildUnnamed2877();
+    o.callSetIds = buildUnnamed2971();
     o.end = "foo";
     o.maxCalls = 42;
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceName = "foo";
     o.start = "foo";
     o.variantName = "foo";
-    o.variantSetIds = buildUnnamed2878();
+    o.variantSetIds = buildUnnamed2972();
   }
   buildCounterSearchVariantsRequest--;
   return o;
 }
 
 checkSearchVariantsRequest(api.SearchVariantsRequest o) {
   buildCounterSearchVariantsRequest++;
   if (buildCounterSearchVariantsRequest < 3) {
-    checkUnnamed2877(o.callSetIds);
+    checkUnnamed2971(o.callSetIds);
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.maxCalls, unittest.equals(42));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
     unittest.expect(o.variantName, unittest.equals('foo'));
-    checkUnnamed2878(o.variantSetIds);
+    checkUnnamed2972(o.variantSetIds);
   }
   buildCounterSearchVariantsRequest--;
 }
 
-buildUnnamed2879() {
+buildUnnamed2973() {
   var o = new core.List<api.Variant>();
   o.add(buildVariant());
   o.add(buildVariant());
   return o;
 }
 
-checkUnnamed2879(core.List<api.Variant> o) {
+checkUnnamed2973(core.List<api.Variant> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariant(o[0]);
   checkVariant(o[1]);
 }
 
 core.int buildCounterSearchVariantsResponse = 0;
 buildSearchVariantsResponse() {
   var o = new api.SearchVariantsResponse();
   buildCounterSearchVariantsResponse++;
   if (buildCounterSearchVariantsResponse < 3) {
     o.nextPageToken = "foo";
-    o.variants = buildUnnamed2879();
+    o.variants = buildUnnamed2973();
   }
   buildCounterSearchVariantsResponse--;
   return o;
 }
 
 checkSearchVariantsResponse(api.SearchVariantsResponse o) {
   buildCounterSearchVariantsResponse++;
   if (buildCounterSearchVariantsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed2879(o.variants);
+    checkUnnamed2973(o.variants);
   }
   buildCounterSearchVariantsResponse--;
 }
 
 core.int buildCounterSetIamPolicyRequest = 0;
 buildSetIamPolicyRequest() {
   var o = new api.SetIamPolicyRequest();
   buildCounterSetIamPolicyRequest++;
   if (buildCounterSetIamPolicyRequest < 3) {
     o.policy = buildPolicy();
   }
   buildCounterSetIamPolicyRequest--;
   return o;
 }
 
 checkSetIamPolicyRequest(api.SetIamPolicyRequest o) {
   buildCounterSetIamPolicyRequest++;
   if (buildCounterSetIamPolicyRequest < 3) {
     checkPolicy(o.policy);
   }
   buildCounterSetIamPolicyRequest--;
 }
 
-buildUnnamed2880() {
+buildUnnamed2974() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed2880(core.Map<core.String, core.Object> o) {
+checkUnnamed2974(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted21 = (o["x"]) as core.Map; unittest.expect(casted21, unittest.hasLength(3)); unittest.expect(casted21["list"], unittest.equals([1, 2, 3])); unittest.expect(casted21["bool"], unittest.equals(true)); unittest.expect(casted21["string"], unittest.equals('foo')); 
   var casted22 = (o["y"]) as core.Map; unittest.expect(casted22, unittest.hasLength(3)); unittest.expect(casted22["list"], unittest.equals([1, 2, 3])); unittest.expect(casted22["bool"], unittest.equals(true)); unittest.expect(casted22["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2881() {
+buildUnnamed2975() {
   var o = new core.List<core.Map<core.String, core.Object>>();
-  o.add(buildUnnamed2880());
-  o.add(buildUnnamed2880());
+  o.add(buildUnnamed2974());
+  o.add(buildUnnamed2974());
   return o;
 }
 
-checkUnnamed2881(core.List<core.Map<core.String, core.Object>> o) {
+checkUnnamed2975(core.List<core.Map<core.String, core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2880(o[0]);
-  checkUnnamed2880(o[1]);
+  checkUnnamed2974(o[0]);
+  checkUnnamed2974(o[1]);
 }
 
 core.int buildCounterStatus = 0;
 buildStatus() {
   var o = new api.Status();
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     o.code = 42;
-    o.details = buildUnnamed2881();
+    o.details = buildUnnamed2975();
     o.message = "foo";
   }
   buildCounterStatus--;
   return o;
 }
 
 checkStatus(api.Status o) {
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     unittest.expect(o.code, unittest.equals(42));
-    checkUnnamed2881(o.details);
+    checkUnnamed2975(o.details);
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterStatus--;
 }
 
-core.int buildCounterStreamReadsRequest = 0;
-buildStreamReadsRequest() {
-  var o = new api.StreamReadsRequest();
-  buildCounterStreamReadsRequest++;
-  if (buildCounterStreamReadsRequest < 3) {
-    o.end = "foo";
-    o.projectId = "foo";
-    o.readGroupSetId = "foo";
-    o.referenceName = "foo";
-    o.shard = 42;
-    o.start = "foo";
-    o.totalShards = 42;
-  }
-  buildCounterStreamReadsRequest--;
-  return o;
-}
-
-checkStreamReadsRequest(api.StreamReadsRequest o) {
-  buildCounterStreamReadsRequest++;
-  if (buildCounterStreamReadsRequest < 3) {
-    unittest.expect(o.end, unittest.equals('foo'));
-    unittest.expect(o.projectId, unittest.equals('foo'));
-    unittest.expect(o.readGroupSetId, unittest.equals('foo'));
-    unittest.expect(o.referenceName, unittest.equals('foo'));
-    unittest.expect(o.shard, unittest.equals(42));
-    unittest.expect(o.start, unittest.equals('foo'));
-    unittest.expect(o.totalShards, unittest.equals(42));
-  }
-  buildCounterStreamReadsRequest--;
-}
-
-buildUnnamed2882() {
-  var o = new core.List<api.Read>();
-  o.add(buildRead());
-  o.add(buildRead());
-  return o;
-}
-
-checkUnnamed2882(core.List<api.Read> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkRead(o[0]);
-  checkRead(o[1]);
-}
-
-core.int buildCounterStreamReadsResponse = 0;
-buildStreamReadsResponse() {
-  var o = new api.StreamReadsResponse();
-  buildCounterStreamReadsResponse++;
-  if (buildCounterStreamReadsResponse < 3) {
-    o.alignments = buildUnnamed2882();
-  }
-  buildCounterStreamReadsResponse--;
-  return o;
-}
-
-checkStreamReadsResponse(api.StreamReadsResponse o) {
-  buildCounterStreamReadsResponse++;
-  if (buildCounterStreamReadsResponse < 3) {
-    checkUnnamed2882(o.alignments);
-  }
-  buildCounterStreamReadsResponse--;
-}
-
-buildUnnamed2883() {
+buildUnnamed2976() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2883(core.List<core.String> o) {
+checkUnnamed2976(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
-}
-
-core.int buildCounterStreamVariantsRequest = 0;
-buildStreamVariantsRequest() {
-  var o = new api.StreamVariantsRequest();
-  buildCounterStreamVariantsRequest++;
-  if (buildCounterStreamVariantsRequest < 3) {
-    o.callSetIds = buildUnnamed2883();
-    o.end = "foo";
-    o.projectId = "foo";
-    o.referenceName = "foo";
-    o.start = "foo";
-    o.variantSetId = "foo";
-  }
-  buildCounterStreamVariantsRequest--;
-  return o;
-}
-
-checkStreamVariantsRequest(api.StreamVariantsRequest o) {
-  buildCounterStreamVariantsRequest++;
-  if (buildCounterStreamVariantsRequest < 3) {
-    checkUnnamed2883(o.callSetIds);
-    unittest.expect(o.end, unittest.equals('foo'));
-    unittest.expect(o.projectId, unittest.equals('foo'));
-    unittest.expect(o.referenceName, unittest.equals('foo'));
-    unittest.expect(o.start, unittest.equals('foo'));
-    unittest.expect(o.variantSetId, unittest.equals('foo'));
-  }
-  buildCounterStreamVariantsRequest--;
-}
-
-buildUnnamed2884() {
-  var o = new core.List<api.Variant>();
-  o.add(buildVariant());
-  o.add(buildVariant());
-  return o;
-}
-
-checkUnnamed2884(core.List<api.Variant> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkVariant(o[0]);
-  checkVariant(o[1]);
-}
-
-core.int buildCounterStreamVariantsResponse = 0;
-buildStreamVariantsResponse() {
-  var o = new api.StreamVariantsResponse();
-  buildCounterStreamVariantsResponse++;
-  if (buildCounterStreamVariantsResponse < 3) {
-    o.variants = buildUnnamed2884();
-  }
-  buildCounterStreamVariantsResponse--;
-  return o;
-}
-
-checkStreamVariantsResponse(api.StreamVariantsResponse o) {
-  buildCounterStreamVariantsResponse++;
-  if (buildCounterStreamVariantsResponse < 3) {
-    checkUnnamed2884(o.variants);
-  }
-  buildCounterStreamVariantsResponse--;
-}
-
-buildUnnamed2885() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed2885(core.List<core.String> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  unittest.expect(o[0], unittest.equals('foo'));
-  unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterTestIamPermissionsRequest = 0;
 buildTestIamPermissionsRequest() {
   var o = new api.TestIamPermissionsRequest();
   buildCounterTestIamPermissionsRequest++;
   if (buildCounterTestIamPermissionsRequest < 3) {
-    o.permissions = buildUnnamed2885();
+    o.permissions = buildUnnamed2976();
   }
   buildCounterTestIamPermissionsRequest--;
   return o;
 }
 
 checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
   buildCounterTestIamPermissionsRequest++;
   if (buildCounterTestIamPermissionsRequest < 3) {
-    checkUnnamed2885(o.permissions);
+    checkUnnamed2976(o.permissions);
   }
   buildCounterTestIamPermissionsRequest--;
 }
 
-buildUnnamed2886() {
+buildUnnamed2977() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2886(core.List<core.String> o) {
+checkUnnamed2977(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterTestIamPermissionsResponse = 0;
 buildTestIamPermissionsResponse() {
   var o = new api.TestIamPermissionsResponse();
   buildCounterTestIamPermissionsResponse++;
   if (buildCounterTestIamPermissionsResponse < 3) {
-    o.permissions = buildUnnamed2886();
+    o.permissions = buildUnnamed2977();
   }
   buildCounterTestIamPermissionsResponse--;
   return o;
 }
 
 checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
   buildCounterTestIamPermissionsResponse++;
   if (buildCounterTestIamPermissionsResponse < 3) {
-    checkUnnamed2886(o.permissions);
+    checkUnnamed2977(o.permissions);
   }
   buildCounterTestIamPermissionsResponse--;
 }
 
-buildUnnamed2887() {
+buildUnnamed2978() {
   var o = new core.List<api.Exon>();
   o.add(buildExon());
   o.add(buildExon());
   return o;
 }
 
-checkUnnamed2887(core.List<api.Exon> o) {
+checkUnnamed2978(core.List<api.Exon> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkExon(o[0]);
   checkExon(o[1]);
 }
 
 core.int buildCounterTranscript = 0;
 buildTranscript() {
   var o = new api.Transcript();
   buildCounterTranscript++;
   if (buildCounterTranscript < 3) {
     o.codingSequence = buildCodingSequence();
-    o.exons = buildUnnamed2887();
+    o.exons = buildUnnamed2978();
     o.geneId = "foo";
   }
   buildCounterTranscript--;
   return o;
 }
 
 checkTranscript(api.Transcript o) {
   buildCounterTranscript++;
   if (buildCounterTranscript < 3) {
     checkCodingSequence(o.codingSequence);
-    checkUnnamed2887(o.exons);
+    checkUnnamed2978(o.exons);
     unittest.expect(o.geneId, unittest.equals('foo'));
   }
   buildCounterTranscript--;
 }
 
 core.int buildCounterUndeleteDatasetRequest = 0;
 buildUndeleteDatasetRequest() {
   var o = new api.UndeleteDatasetRequest();
   buildCounterUndeleteDatasetRequest++;
   if (buildCounterUndeleteDatasetRequest < 3) {
   }
   buildCounterUndeleteDatasetRequest--;
   return o;
 }
 
 checkUndeleteDatasetRequest(api.UndeleteDatasetRequest o) {
   buildCounterUndeleteDatasetRequest++;
   if (buildCounterUndeleteDatasetRequest < 3) {
   }
   buildCounterUndeleteDatasetRequest--;
 }
 
-buildUnnamed2888() {
+buildUnnamed2979() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2888(core.List<core.String> o) {
+checkUnnamed2979(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2889() {
+buildUnnamed2980() {
   var o = new core.List<api.VariantCall>();
   o.add(buildVariantCall());
   o.add(buildVariantCall());
   return o;
 }
 
-checkUnnamed2889(core.List<api.VariantCall> o) {
+checkUnnamed2980(core.List<api.VariantCall> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariantCall(o[0]);
   checkVariantCall(o[1]);
 }
 
-buildUnnamed2890() {
+buildUnnamed2981() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2890(core.List<core.String> o) {
+checkUnnamed2981(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed2891() {
+buildUnnamed2982() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2891(core.List<core.Object> o) {
+checkUnnamed2982(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted23 = (o[0]) as core.Map; unittest.expect(casted23, unittest.hasLength(3)); unittest.expect(casted23["list"], unittest.equals([1, 2, 3])); unittest.expect(casted23["bool"], unittest.equals(true)); unittest.expect(casted23["string"], unittest.equals('foo')); 
   var casted24 = (o[1]) as core.Map; unittest.expect(casted24, unittest.hasLength(3)); unittest.expect(casted24["list"], unittest.equals([1, 2, 3])); unittest.expect(casted24["bool"], unittest.equals(true)); unittest.expect(casted24["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2892() {
+buildUnnamed2983() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2891();
-  o["y"] = buildUnnamed2891();
+  o["x"] = buildUnnamed2982();
+  o["y"] = buildUnnamed2982();
   return o;
 }
 
-checkUnnamed2892(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2983(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2891(o["x"]);
-  checkUnnamed2891(o["y"]);
+  checkUnnamed2982(o["x"]);
+  checkUnnamed2982(o["y"]);
 }
 
-buildUnnamed2893() {
+buildUnnamed2984() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2893(core.List<core.String> o) {
+checkUnnamed2984(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterVariant = 0;
 buildVariant() {
   var o = new api.Variant();
   buildCounterVariant++;
   if (buildCounterVariant < 3) {
-    o.alternateBases = buildUnnamed2888();
-    o.calls = buildUnnamed2889();
+    o.alternateBases = buildUnnamed2979();
+    o.calls = buildUnnamed2980();
     o.created = "foo";
     o.end = "foo";
-    o.filter = buildUnnamed2890();
+    o.filter = buildUnnamed2981();
     o.id = "foo";
-    o.info = buildUnnamed2892();
-    o.names = buildUnnamed2893();
+    o.info = buildUnnamed2983();
+    o.names = buildUnnamed2984();
     o.quality = 42.0;
     o.referenceBases = "foo";
     o.referenceName = "foo";
     o.start = "foo";
     o.variantSetId = "foo";
   }
   buildCounterVariant--;
   return o;
 }
 
 checkVariant(api.Variant o) {
   buildCounterVariant++;
   if (buildCounterVariant < 3) {
-    checkUnnamed2888(o.alternateBases);
-    checkUnnamed2889(o.calls);
+    checkUnnamed2979(o.alternateBases);
+    checkUnnamed2980(o.calls);
     unittest.expect(o.created, unittest.equals('foo'));
     unittest.expect(o.end, unittest.equals('foo'));
-    checkUnnamed2890(o.filter);
+    checkUnnamed2981(o.filter);
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2892(o.info);
-    checkUnnamed2893(o.names);
+    checkUnnamed2983(o.info);
+    checkUnnamed2984(o.names);
     unittest.expect(o.quality, unittest.equals(42.0));
     unittest.expect(o.referenceBases, unittest.equals('foo'));
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
     unittest.expect(o.variantSetId, unittest.equals('foo'));
   }
   buildCounterVariant--;
 }
 
-buildUnnamed2894() {
+buildUnnamed2985() {
   var o = new core.List<api.ClinicalCondition>();
   o.add(buildClinicalCondition());
   o.add(buildClinicalCondition());
   return o;
 }
 
-checkUnnamed2894(core.List<api.ClinicalCondition> o) {
+checkUnnamed2985(core.List<api.ClinicalCondition> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkClinicalCondition(o[0]);
   checkClinicalCondition(o[1]);
 }
 
-buildUnnamed2895() {
+buildUnnamed2986() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed2895(core.List<core.String> o) {
+checkUnnamed2986(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterVariantAnnotation = 0;
 buildVariantAnnotation() {
   var o = new api.VariantAnnotation();
   buildCounterVariantAnnotation++;
   if (buildCounterVariantAnnotation < 3) {
     o.alternateBases = "foo";
     o.clinicalSignificance = "foo";
-    o.conditions = buildUnnamed2894();
+    o.conditions = buildUnnamed2985();
     o.effect = "foo";
     o.geneId = "foo";
-    o.transcriptIds = buildUnnamed2895();
+    o.transcriptIds = buildUnnamed2986();
     o.type = "foo";
   }
   buildCounterVariantAnnotation--;
   return o;
 }
 
 checkVariantAnnotation(api.VariantAnnotation o) {
   buildCounterVariantAnnotation++;
   if (buildCounterVariantAnnotation < 3) {
     unittest.expect(o.alternateBases, unittest.equals('foo'));
     unittest.expect(o.clinicalSignificance, unittest.equals('foo'));
-    checkUnnamed2894(o.conditions);
+    checkUnnamed2985(o.conditions);
     unittest.expect(o.effect, unittest.equals('foo'));
     unittest.expect(o.geneId, unittest.equals('foo'));
-    checkUnnamed2895(o.transcriptIds);
+    checkUnnamed2986(o.transcriptIds);
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterVariantAnnotation--;
 }
 
-buildUnnamed2896() {
+buildUnnamed2987() {
   var o = new core.List<core.int>();
   o.add(42);
   o.add(42);
   return o;
 }
 
-checkUnnamed2896(core.List<core.int> o) {
+checkUnnamed2987(core.List<core.int> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals(42));
   unittest.expect(o[1], unittest.equals(42));
 }
 
-buildUnnamed2897() {
+buildUnnamed2988() {
   var o = new core.List<core.double>();
   o.add(42.0);
   o.add(42.0);
   return o;
 }
 
-checkUnnamed2897(core.List<core.double> o) {
+checkUnnamed2988(core.List<core.double> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals(42.0));
   unittest.expect(o[1], unittest.equals(42.0));
 }
 
-buildUnnamed2898() {
+buildUnnamed2989() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2898(core.List<core.Object> o) {
+checkUnnamed2989(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted25 = (o[0]) as core.Map; unittest.expect(casted25, unittest.hasLength(3)); unittest.expect(casted25["list"], unittest.equals([1, 2, 3])); unittest.expect(casted25["bool"], unittest.equals(true)); unittest.expect(casted25["string"], unittest.equals('foo')); 
   var casted26 = (o[1]) as core.Map; unittest.expect(casted26, unittest.hasLength(3)); unittest.expect(casted26["list"], unittest.equals([1, 2, 3])); unittest.expect(casted26["bool"], unittest.equals(true)); unittest.expect(casted26["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2899() {
+buildUnnamed2990() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2898();
-  o["y"] = buildUnnamed2898();
+  o["x"] = buildUnnamed2989();
+  o["y"] = buildUnnamed2989();
   return o;
 }
 
-checkUnnamed2899(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2990(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2898(o["x"]);
-  checkUnnamed2898(o["y"]);
+  checkUnnamed2989(o["x"]);
+  checkUnnamed2989(o["y"]);
 }
 
 core.int buildCounterVariantCall = 0;
 buildVariantCall() {
   var o = new api.VariantCall();
   buildCounterVariantCall++;
   if (buildCounterVariantCall < 3) {
     o.callSetId = "foo";
     o.callSetName = "foo";
-    o.genotype = buildUnnamed2896();
-    o.genotypeLikelihood = buildUnnamed2897();
-    o.info = buildUnnamed2899();
+    o.genotype = buildUnnamed2987();
+    o.genotypeLikelihood = buildUnnamed2988();
+    o.info = buildUnnamed2990();
     o.phaseset = "foo";
   }
   buildCounterVariantCall--;
   return o;
 }
 
 checkVariantCall(api.VariantCall o) {
   buildCounterVariantCall++;
   if (buildCounterVariantCall < 3) {
     unittest.expect(o.callSetId, unittest.equals('foo'));
     unittest.expect(o.callSetName, unittest.equals('foo'));
-    checkUnnamed2896(o.genotype);
-    checkUnnamed2897(o.genotypeLikelihood);
-    checkUnnamed2899(o.info);
+    checkUnnamed2987(o.genotype);
+    checkUnnamed2988(o.genotypeLikelihood);
+    checkUnnamed2990(o.info);
     unittest.expect(o.phaseset, unittest.equals('foo'));
   }
   buildCounterVariantCall--;
 }
 
-buildUnnamed2900() {
+buildUnnamed2991() {
   var o = new core.List<api.VariantSetMetadata>();
   o.add(buildVariantSetMetadata());
   o.add(buildVariantSetMetadata());
   return o;
 }
 
-checkUnnamed2900(core.List<api.VariantSetMetadata> o) {
+checkUnnamed2991(core.List<api.VariantSetMetadata> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariantSetMetadata(o[0]);
   checkVariantSetMetadata(o[1]);
 }
 
-buildUnnamed2901() {
+buildUnnamed2992() {
   var o = new core.List<api.ReferenceBound>();
   o.add(buildReferenceBound());
   o.add(buildReferenceBound());
   return o;
 }
 
-checkUnnamed2901(core.List<api.ReferenceBound> o) {
+checkUnnamed2992(core.List<api.ReferenceBound> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkReferenceBound(o[0]);
   checkReferenceBound(o[1]);
 }
 
 core.int buildCounterVariantSet = 0;
 buildVariantSet() {
   var o = new api.VariantSet();
   buildCounterVariantSet++;
   if (buildCounterVariantSet < 3) {
     o.datasetId = "foo";
     o.description = "foo";
     o.id = "foo";
-    o.metadata = buildUnnamed2900();
+    o.metadata = buildUnnamed2991();
     o.name = "foo";
-    o.referenceBounds = buildUnnamed2901();
+    o.referenceBounds = buildUnnamed2992();
     o.referenceSetId = "foo";
   }
   buildCounterVariantSet--;
   return o;
 }
 
 checkVariantSet(api.VariantSet o) {
   buildCounterVariantSet++;
   if (buildCounterVariantSet < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2900(o.metadata);
+    checkUnnamed2991(o.metadata);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed2901(o.referenceBounds);
+    checkUnnamed2992(o.referenceBounds);
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
   }
   buildCounterVariantSet--;
 }
 
-buildUnnamed2902() {
+buildUnnamed2993() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed2902(core.List<core.Object> o) {
+checkUnnamed2993(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted27 = (o[0]) as core.Map; unittest.expect(casted27, unittest.hasLength(3)); unittest.expect(casted27["list"], unittest.equals([1, 2, 3])); unittest.expect(casted27["bool"], unittest.equals(true)); unittest.expect(casted27["string"], unittest.equals('foo')); 
   var casted28 = (o[1]) as core.Map; unittest.expect(casted28, unittest.hasLength(3)); unittest.expect(casted28["list"], unittest.equals([1, 2, 3])); unittest.expect(casted28["bool"], unittest.equals(true)); unittest.expect(casted28["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed2903() {
+buildUnnamed2994() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed2902();
-  o["y"] = buildUnnamed2902();
+  o["x"] = buildUnnamed2993();
+  o["y"] = buildUnnamed2993();
   return o;
 }
 
-checkUnnamed2903(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed2994(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed2902(o["x"]);
-  checkUnnamed2902(o["y"]);
+  checkUnnamed2993(o["x"]);
+  checkUnnamed2993(o["y"]);
 }
 
 core.int buildCounterVariantSetMetadata = 0;
 buildVariantSetMetadata() {
   var o = new api.VariantSetMetadata();
   buildCounterVariantSetMetadata++;
   if (buildCounterVariantSetMetadata < 3) {
     o.description = "foo";
     o.id = "foo";
-    o.info = buildUnnamed2903();
+    o.info = buildUnnamed2994();
     o.key = "foo";
     o.number = "foo";
     o.type = "foo";
     o.value = "foo";
   }
   buildCounterVariantSetMetadata--;
   return o;
 }
 
 checkVariantSetMetadata(api.VariantSetMetadata o) {
   buildCounterVariantSetMetadata++;
   if (buildCounterVariantSetMetadata < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed2903(o.info);
+    checkUnnamed2994(o.info);
     unittest.expect(o.key, unittest.equals('foo'));
     unittest.expect(o.number, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
     unittest.expect(o.value, unittest.equals('foo'));
   }
   buildCounterVariantSetMetadata--;
 }
 
 
 main() {
@@ skipping 575 matching lines @@
 
   unittest.group("obj-schema-Status", () {
     unittest.test("to-json--from-json", () {
       var o = buildStatus();
       var od = new api.Status.fromJson(o.toJson());
       checkStatus(od);
     });
   });
 
 
-  unittest.group("obj-schema-StreamReadsRequest", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildStreamReadsRequest();
-      var od = new api.StreamReadsRequest.fromJson(o.toJson());
-      checkStreamReadsRequest(od);
-    });
-  });
-
-
-  unittest.group("obj-schema-StreamReadsResponse", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildStreamReadsResponse();
-      var od = new api.StreamReadsResponse.fromJson(o.toJson());
-      checkStreamReadsResponse(od);
-    });
-  });
-
-
-  unittest.group("obj-schema-StreamVariantsRequest", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildStreamVariantsRequest();
-      var od = new api.StreamVariantsRequest.fromJson(o.toJson());
-      checkStreamVariantsRequest(od);
-    });
-  });
-
-
-  unittest.group("obj-schema-StreamVariantsResponse", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildStreamVariantsResponse();
-      var od = new api.StreamVariantsResponse.fromJson(o.toJson());
-      checkStreamVariantsResponse(od);
-    });
-  });
-
-
   unittest.group("obj-schema-TestIamPermissionsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildTestIamPermissionsRequest();
       var od = new api.TestIamPermissionsRequest.fromJson(o.toJson());
       checkTestIamPermissionsRequest(od);
     });
   });
 
 
   unittest.group("obj-schema-TestIamPermissionsResponse", () {
@@ skipping 1038 matching lines @@
       }), true);
       res.getIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
         checkPolicy(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
+      var arg_pageSize = 42;
       var arg_projectId = "foo";
-      var arg_pageSize = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("v1/datasets"));
         pathOffset += 11;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["projectId"].first, unittest.equals(arg_projectId));
-        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListDatasetsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(projectId: arg_projectId, pageSize: arg_pageSize, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListDatasetsResponse response) {
+      res.list(pageSize: arg_pageSize, projectId: arg_projectId, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListDatasetsResponse response) {
         checkListDatasetsResponse(response);
       })));
     });
 
     unittest.test("method--patch", () {
 
       var mock = new HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_request = buildDataset();
       var arg_datasetId = "foo";
@@ skipping 293 matching lines @@
       res.get(arg_name).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.OperationsResourceApi res = new api.GenomicsApi(mock).operations;
       var arg_name = "foo";
+      var arg_pageSize = 42;
       var arg_filter = "foo";
-      var arg_pageSize = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
-        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListOperationsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_name, filter: arg_filter, pageSize: arg_pageSize, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListOperationsResponse response) {
+      res.list(arg_name, pageSize: arg_pageSize, filter: arg_filter, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListOperationsResponse response) {
         checkListOperationsResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-ReadgroupsetsResourceApi", () {
     unittest.test("method--delete", () {
 
@@ skipping 293 matching lines @@
 
   });
 
 
   unittest.group("resource-ReadgroupsetsCoveragebucketsResourceApi", () {
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.ReadgroupsetsCoveragebucketsResourceApi res = new api.GenomicsApi(mock).readgroupsets.coveragebuckets;
       var arg_readGroupSetId = "foo";
+      var arg_pageSize = 42;
+      var arg_start = "foo";
+      var arg_targetBucketWidth = "foo";
       var arg_referenceName = "foo";
-      var arg_start = "foo";
       var arg_end = "foo";
-      var arg_targetBucketWidth = "foo";
       var arg_pageToken = "foo";
-      var arg_pageSize = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("v1/readgroupsets/"));
         pathOffset += 17;
         index = path.indexOf("/coveragebuckets", pathOffset);
@@ skipping 13 matching lines @@
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
+        unittest.expect(queryMap["start"].first, unittest.equals(arg_start));
+        unittest.expect(queryMap["targetBucketWidth"].first, unittest.equals(arg_targetBucketWidth));
         unittest.expect(queryMap["referenceName"].first, unittest.equals(arg_referenceName));
-        unittest.expect(queryMap["start"].first, unittest.equals(arg_start));
         unittest.expect(queryMap["end"].first, unittest.equals(arg_end));
-        unittest.expect(queryMap["targetBucketWidth"].first, unittest.equals(arg_targetBucketWidth));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListCoverageBucketsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_readGroupSetId, referenceName: arg_referenceName, start: arg_start, end: arg_end, targetBucketWidth: arg_targetBucketWidth, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync(((api.ListCoverageBucketsResponse response) {
+      res.list(arg_readGroupSetId, pageSize: arg_pageSize, start: arg_start, targetBucketWidth: arg_targetBucketWidth, referenceName: arg_referenceName, end: arg_end, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListCoverageBucketsResponse response) {
         checkListCoverageBucketsResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-ReadsResourceApi", () {
     unittest.test("method--search", () {
 
@@ skipping 35 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSearchReadsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsResponse response) {
         checkSearchReadsResponse(response);
       })));
     });
 
-    unittest.test("method--stream", () {
-
-      var mock = new HttpServerMock();
-      api.ReadsResourceApi res = new api.GenomicsApi(mock).reads;
-      var arg_request = buildStreamReadsRequest();
-      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.StreamReadsRequest.fromJson(json);
-        checkStreamReadsRequest(obj);
-
-        var path = (req.url).path;
-        var pathOffset = 0;
-        var index;
-        var subPart;
-        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
-        pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("v1/reads:stream"));
-        pathOffset += 15;
-
-        var query = (req.url).query;
-        var queryOffset = 0;
-        var queryMap = {};
-        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
-        parseBool(n) {
-          if (n == "true") return true;
-          if (n == "false") return false;
-          if (n == null) return null;
-          throw new core.ArgumentError("Invalid boolean: $n");
-        }
-        if (query.length > 0) {
-          for (var part in query.split("&")) {
-            var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
-          }
-        }
-
-
-        var h = {
-          "content-type" : "application/json; charset=utf-8",
-        };
-        var resp = convert.JSON.encode(buildStreamReadsResponse());
-        return new async.Future.value(stringResponse(200, h, resp));
-      }), true);
-      res.stream(arg_request).then(unittest.expectAsync(((api.StreamReadsResponse response) {
-        checkStreamReadsResponse(response);
-      })));
-    });
-
   });
 
 
   unittest.group("resource-ReferencesResourceApi", () {
     unittest.test("method--get", () {
 
       var mock = new HttpServerMock();
       api.ReferencesResourceApi res = new api.GenomicsApi(mock).references;
       var arg_referenceId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 87 matching lines @@
 
   });
 
 
   unittest.group("resource-ReferencesBasesResourceApi", () {
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.ReferencesBasesResourceApi res = new api.GenomicsApi(mock).references.bases;
       var arg_referenceId = "foo";
+      var arg_pageSize = 42;
       var arg_start = "foo";
       var arg_end = "foo";
       var arg_pageToken = "foo";
-      var arg_pageSize = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("v1/references/"));
         pathOffset += 14;
         index = path.indexOf("/bases", pathOffset);
@@ skipping 13 matching lines @@
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["start"].first, unittest.equals(arg_start));
         unittest.expect(queryMap["end"].first, unittest.equals(arg_end));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListBasesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_referenceId, start: arg_start, end: arg_end, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync(((api.ListBasesResponse response) {
+      res.list(arg_referenceId, pageSize: arg_pageSize, start: arg_start, end: arg_end, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListBasesResponse response) {
         checkListBasesResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-ReferencesetsResourceApi", () {
     unittest.test("method--get", () {
 
@@ skipping 421 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSearchVariantsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantsResponse response) {
         checkSearchVariantsResponse(response);
       })));
     });
 
-    unittest.test("method--stream", () {
-
-      var mock = new HttpServerMock();
-      api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
-      var arg_request = buildStreamVariantsRequest();
-      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.StreamVariantsRequest.fromJson(json);
-        checkStreamVariantsRequest(obj);
-
-        var path = (req.url).path;
-        var pathOffset = 0;
-        var index;
-        var subPart;
-        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
-        pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("v1/variants:stream"));
-        pathOffset += 18;
-
-        var query = (req.url).query;
-        var queryOffset = 0;
-        var queryMap = {};
-        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
-        parseBool(n) {
-          if (n == "true") return true;
-          if (n == "false") return false;
-          if (n == null) return null;
-          throw new core.ArgumentError("Invalid boolean: $n");
-        }
-        if (query.length > 0) {
-          for (var part in query.split("&")) {
-            var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
-          }
-        }
-
-
-        var h = {
-          "content-type" : "application/json; charset=utf-8",
-        };
-        var resp = convert.JSON.encode(buildStreamVariantsResponse());
-        return new async.Future.value(stringResponse(200, h, resp));
-      }), true);
-      res.stream(arg_request).then(unittest.expectAsync(((api.StreamVariantsResponse response) {
-        checkStreamVariantsResponse(response);
-      })));
-    });
-
   });
 
 
   unittest.group("resource-VariantsetsResourceApi", () {
     unittest.test("method--create", () {
 
       var mock = new HttpServerMock();
       api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;
       var arg_request = buildVariantSet();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 285 matching lines @@
       res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantSetsResponse response) {
         checkSearchVariantSetsResponse(response);
       })));
     });
 
   });
 
 
 }