Api roll 5: 2014-11-05

generated/googleapis_beta/test/genomics/v1beta2_test.dart

-library googleapis_beta.genomics.v1beta.test;
+library googleapis_beta.genomics.v1beta2.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;
 import 'package:googleapis_beta/common/common.dart' as common;
 import 'package:googleapis_beta/src/common_internal.dart' as common_internal;
 import '../common/common_internal_test.dart' as common_test;
 
-import 'package:googleapis_beta/genomics/v1beta.dart' as api;
+import 'package:googleapis_beta/genomics/v1beta2.dart' as api;
 
 
 
-core.int buildCounterBeacon = 0;
-buildBeacon() {
-  var o = new api.Beacon();
-  buildCounterBeacon++;
-  if (buildCounterBeacon < 3) {
-    o.exists = true;
-  }
-  buildCounterBeacon--;
+buildUnnamed1267() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
   return o;
 }
 
-checkBeacon(api.Beacon o) {
-  buildCounterBeacon++;
-  if (buildCounterBeacon < 3) {
-    unittest.expect(o.exists, unittest.isTrue);
-  }
-  buildCounterBeacon--;
+checkUnnamed1267(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'));
 }
 
-buildUnnamed1213() {
+buildUnnamed1268() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1268(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 buildCounterAlignReadGroupSetsRequest = 0;
+buildAlignReadGroupSetsRequest() {
+  var o = new api.AlignReadGroupSetsRequest();
+  buildCounterAlignReadGroupSetsRequest++;
+  if (buildCounterAlignReadGroupSetsRequest < 3) {
+    o.bamSourceUris = buildUnnamed1267();
+    o.datasetId = "foo";
+    o.interleavedFastqSource = buildInterleavedFastqSource();
+    o.pairedFastqSource = buildPairedFastqSource();
+    o.readGroupSetIds = buildUnnamed1268();
+  }
+  buildCounterAlignReadGroupSetsRequest--;
+  return o;
+}
+
+checkAlignReadGroupSetsRequest(api.AlignReadGroupSetsRequest o) {
+  buildCounterAlignReadGroupSetsRequest++;
+  if (buildCounterAlignReadGroupSetsRequest < 3) {
+    checkUnnamed1267(o.bamSourceUris);
+    unittest.expect(o.datasetId, unittest.equals('foo'));
+    checkInterleavedFastqSource(o.interleavedFastqSource);
+    checkPairedFastqSource(o.pairedFastqSource);
+    checkUnnamed1268(o.readGroupSetIds);
+  }
+  buildCounterAlignReadGroupSetsRequest--;
+}
+
+core.int buildCounterAlignReadGroupSetsResponse = 0;
+buildAlignReadGroupSetsResponse() {
+  var o = new api.AlignReadGroupSetsResponse();
+  buildCounterAlignReadGroupSetsResponse++;
+  if (buildCounterAlignReadGroupSetsResponse < 3) {
+    o.jobId = "foo";
+  }
+  buildCounterAlignReadGroupSetsResponse--;
+  return o;
+}
+
+checkAlignReadGroupSetsResponse(api.AlignReadGroupSetsResponse o) {
+  buildCounterAlignReadGroupSetsResponse++;
+  if (buildCounterAlignReadGroupSetsResponse < 3) {
+    unittest.expect(o.jobId, unittest.equals('foo'));
+  }
+  buildCounterAlignReadGroupSetsResponse--;
+}
+
+buildUnnamed1269() {
   var o = new core.List<core.int>();
   o.add(42);
   o.add(42);
   return o;
 }
 
-checkUnnamed1213(core.List<core.int> o) {
+checkUnnamed1269(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));
 }
 
-buildUnnamed1214() {
+buildUnnamed1270() {
   var o = new core.List<core.double>();
   o.add(42.0);
   o.add(42.0);
   return o;
 }
 
-checkUnnamed1214(core.List<core.double> o) {
+checkUnnamed1270(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));
 }
 
-buildUnnamed1215() {
+buildUnnamed1271() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1215(core.List<core.String> o) {
+checkUnnamed1271(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'));
 }
 
-buildUnnamed1216() {
+buildUnnamed1272() {
   var o = new core.Map<core.String, core.List<core.String>>();
-  o["x"] = buildUnnamed1215();
-  o["y"] = buildUnnamed1215();
+  o["x"] = buildUnnamed1271();
+  o["y"] = buildUnnamed1271();
   return o;
 }
 
-checkUnnamed1216(core.Map<core.String, core.List<core.String>> o) {
+checkUnnamed1272(core.Map<core.String, core.List<core.String>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1215(o["x"]);
-  checkUnnamed1215(o["y"]);
+  checkUnnamed1271(o["x"]);
+  checkUnnamed1271(o["y"]);
 }
 
 core.int buildCounterCall = 0;
 buildCall() {
   var o = new api.Call();
   buildCounterCall++;
   if (buildCounterCall < 3) {
     o.callSetId = "foo";
     o.callSetName = "foo";
-    o.genotype = buildUnnamed1213();
-    o.genotypeLikelihood = buildUnnamed1214();
-    o.info = buildUnnamed1216();
+    o.genotype = buildUnnamed1269();
+    o.genotypeLikelihood = buildUnnamed1270();
+    o.info = buildUnnamed1272();
     o.phaseset = "foo";
   }
   buildCounterCall--;
   return o;
 }
 
 checkCall(api.Call o) {
   buildCounterCall++;
   if (buildCounterCall < 3) {
     unittest.expect(o.callSetId, unittest.equals('foo'));
     unittest.expect(o.callSetName, unittest.equals('foo'));
-    checkUnnamed1213(o.genotype);
-    checkUnnamed1214(o.genotypeLikelihood);
-    checkUnnamed1216(o.info);
+    checkUnnamed1269(o.genotype);
+    checkUnnamed1270(o.genotypeLikelihood);
+    checkUnnamed1272(o.info);
     unittest.expect(o.phaseset, unittest.equals('foo'));
   }
   buildCounterCall--;
 }
 
-buildUnnamed1217() {
+buildUnnamed1273() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1217(core.List<core.String> o) {
+checkUnnamed1273(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'));
 }
 
-buildUnnamed1218() {
-  var o = new core.Map<core.String, core.List<core.String>>();
-  o["x"] = buildUnnamed1217();
-  o["y"] = buildUnnamed1217();
-  return o;
-}
-
-checkUnnamed1218(core.Map<core.String, core.List<core.String>> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1217(o["x"]);
-  checkUnnamed1217(o["y"]);
-}
-
-buildUnnamed1219() {
+buildUnnamed1274() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1219(core.List<core.String> o) {
+checkUnnamed1274(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 buildCounterCallReadGroupSetsRequest = 0;
+buildCallReadGroupSetsRequest() {
+  var o = new api.CallReadGroupSetsRequest();
+  buildCounterCallReadGroupSetsRequest++;
+  if (buildCounterCallReadGroupSetsRequest < 3) {
+    o.datasetId = "foo";
+    o.readGroupSetIds = buildUnnamed1273();
+    o.sourceUris = buildUnnamed1274();
+  }
+  buildCounterCallReadGroupSetsRequest--;
+  return o;
+}
+
+checkCallReadGroupSetsRequest(api.CallReadGroupSetsRequest o) {
+  buildCounterCallReadGroupSetsRequest++;
+  if (buildCounterCallReadGroupSetsRequest < 3) {
+    unittest.expect(o.datasetId, unittest.equals('foo'));
+    checkUnnamed1273(o.readGroupSetIds);
+    checkUnnamed1274(o.sourceUris);
+  }
+  buildCounterCallReadGroupSetsRequest--;
+}
+
+core.int buildCounterCallReadGroupSetsResponse = 0;
+buildCallReadGroupSetsResponse() {
+  var o = new api.CallReadGroupSetsResponse();
+  buildCounterCallReadGroupSetsResponse++;
+  if (buildCounterCallReadGroupSetsResponse < 3) {
+    o.jobId = "foo";
+  }
+  buildCounterCallReadGroupSetsResponse--;
+  return o;
+}
+
+checkCallReadGroupSetsResponse(api.CallReadGroupSetsResponse o) {
+  buildCounterCallReadGroupSetsResponse++;
+  if (buildCounterCallReadGroupSetsResponse < 3) {
+    unittest.expect(o.jobId, unittest.equals('foo'));
+  }
+  buildCounterCallReadGroupSetsResponse--;
+}
+
+buildUnnamed1275() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1275(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'));
+}
+
+buildUnnamed1276() {
+  var o = new core.Map<core.String, core.List<core.String>>();
+  o["x"] = buildUnnamed1275();
+  o["y"] = buildUnnamed1275();
+  return o;
+}
+
+checkUnnamed1276(core.Map<core.String, core.List<core.String>> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUnnamed1275(o["x"]);
+  checkUnnamed1275(o["y"]);
+}
+
+buildUnnamed1277() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1277(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 = buildUnnamed1218();
+    o.info = buildUnnamed1276();
     o.name = "foo";
     o.sampleId = "foo";
-    o.variantSetIds = buildUnnamed1219();
+    o.variantSetIds = buildUnnamed1277();
   }
   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'));
-    checkUnnamed1218(o.info);
+    checkUnnamed1276(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.sampleId, unittest.equals('foo'));
-    checkUnnamed1219(o.variantSetIds);
+    checkUnnamed1277(o.variantSetIds);
   }
   buildCounterCallSet--;
 }
 
+core.int buildCounterCigarUnit = 0;
+buildCigarUnit() {
+  var o = new api.CigarUnit();
+  buildCounterCigarUnit++;
+  if (buildCounterCigarUnit < 3) {
+    o.operation = "foo";
+    o.operationLength = "foo";
+    o.referenceSequence = "foo";
+  }
+  buildCounterCigarUnit--;
+  return o;
+}
+
+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--;
+}
+
 core.int buildCounterCoverageBucket = 0;
 buildCoverageBucket() {
   var o = new api.CoverageBucket();
   buildCounterCoverageBucket++;
   if (buildCounterCoverageBucket < 3) {
     o.meanCoverage = 42.0;
-    o.range = buildGenomicRange();
+    o.range = buildRange();
   }
   buildCounterCoverageBucket--;
   return o;
 }
 
 checkCoverageBucket(api.CoverageBucket o) {
   buildCounterCoverageBucket++;
   if (buildCounterCoverageBucket < 3) {
     unittest.expect(o.meanCoverage, unittest.equals(42.0));
-    checkGenomicRange(o.range);
+    checkRange(o.range);
   }
   buildCounterCoverageBucket--;
 }
 
 core.int buildCounterDataset = 0;
 buildDataset() {
   var o = new api.Dataset();
   buildCounterDataset++;
   if (buildCounterDataset < 3) {
     o.id = "foo";
     o.isPublic = true;
     o.name = "foo";
-    o.projectId = "foo";
+    o.projectNumber = "foo";
   }
   buildCounterDataset--;
   return o;
 }
 
 checkDataset(api.Dataset o) {
   buildCounterDataset++;
   if (buildCounterDataset < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.isPublic, unittest.isTrue);
     unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.projectId, unittest.equals('foo'));
+    unittest.expect(o.projectNumber, unittest.equals('foo'));
   }
   buildCounterDataset--;
 }
 
-buildUnnamed1220() {
+buildUnnamed1278() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1220(core.List<core.String> o) {
+checkUnnamed1278(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'));
 }
 
-buildUnnamed1221() {
+buildUnnamed1279() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1221(core.List<core.String> o) {
+checkUnnamed1279(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 buildCounterExperimentalCreateJobRequest = 0;
 buildExperimentalCreateJobRequest() {
   var o = new api.ExperimentalCreateJobRequest();
   buildCounterExperimentalCreateJobRequest++;
   if (buildCounterExperimentalCreateJobRequest < 3) {
     o.align = true;
     o.callVariants = true;
     o.gcsOutputPath = "foo";
-    o.pairedSourceUris = buildUnnamed1220();
-    o.projectId = "foo";
-    o.sourceUris = buildUnnamed1221();
+    o.pairedSourceUris = buildUnnamed1278();
+    o.projectNumber = "foo";
+    o.sourceUris = buildUnnamed1279();
   }
   buildCounterExperimentalCreateJobRequest--;
   return o;
 }
 
 checkExperimentalCreateJobRequest(api.ExperimentalCreateJobRequest o) {
   buildCounterExperimentalCreateJobRequest++;
   if (buildCounterExperimentalCreateJobRequest < 3) {
     unittest.expect(o.align, unittest.isTrue);
     unittest.expect(o.callVariants, unittest.isTrue);
     unittest.expect(o.gcsOutputPath, unittest.equals('foo'));
-    checkUnnamed1220(o.pairedSourceUris);
-    unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed1221(o.sourceUris);
+    checkUnnamed1278(o.pairedSourceUris);
+    unittest.expect(o.projectNumber, unittest.equals('foo'));
+    checkUnnamed1279(o.sourceUris);
   }
   buildCounterExperimentalCreateJobRequest--;
 }
 
 core.int buildCounterExperimentalCreateJobResponse = 0;
 buildExperimentalCreateJobResponse() {
   var o = new api.ExperimentalCreateJobResponse();
   buildCounterExperimentalCreateJobResponse++;
   if (buildCounterExperimentalCreateJobResponse < 3) {
     o.jobId = "foo";
   }
   buildCounterExperimentalCreateJobResponse--;
   return o;
 }
 
 checkExperimentalCreateJobResponse(api.ExperimentalCreateJobResponse o) {
   buildCounterExperimentalCreateJobResponse++;
   if (buildCounterExperimentalCreateJobResponse < 3) {
     unittest.expect(o.jobId, unittest.equals('foo'));
   }
   buildCounterExperimentalCreateJobResponse--;
 }
 
-buildUnnamed1222() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1222(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'));
-}
-
-buildUnnamed1223() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1223(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 buildCounterExportReadsetsRequest = 0;
-buildExportReadsetsRequest() {
-  var o = new api.ExportReadsetsRequest();
-  buildCounterExportReadsetsRequest++;
-  if (buildCounterExportReadsetsRequest < 3) {
+buildUnnamed1280() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1280(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'));
+}
+
+buildUnnamed1281() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1281(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 buildCounterExportReadGroupSetsRequest = 0;
+buildExportReadGroupSetsRequest() {
+  var o = new api.ExportReadGroupSetsRequest();
+  buildCounterExportReadGroupSetsRequest++;
+  if (buildCounterExportReadGroupSetsRequest < 3) {
     o.exportUri = "foo";
-    o.projectId = "foo";
-    o.readsetIds = buildUnnamed1222();
-    o.referenceNames = buildUnnamed1223();
-  }
-  buildCounterExportReadsetsRequest--;
-  return o;
-}
-
-checkExportReadsetsRequest(api.ExportReadsetsRequest o) {
-  buildCounterExportReadsetsRequest++;
-  if (buildCounterExportReadsetsRequest < 3) {
+    o.projectNumber = "foo";
+    o.readGroupSetIds = buildUnnamed1280();
+    o.referenceNames = buildUnnamed1281();
+  }
+  buildCounterExportReadGroupSetsRequest--;
+  return o;
+}
+
+checkExportReadGroupSetsRequest(api.ExportReadGroupSetsRequest o) {
+  buildCounterExportReadGroupSetsRequest++;
+  if (buildCounterExportReadGroupSetsRequest < 3) {
     unittest.expect(o.exportUri, unittest.equals('foo'));
-    unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed1222(o.readsetIds);
-    checkUnnamed1223(o.referenceNames);
-  }
-  buildCounterExportReadsetsRequest--;
-}
-
-core.int buildCounterExportReadsetsResponse = 0;
-buildExportReadsetsResponse() {
-  var o = new api.ExportReadsetsResponse();
-  buildCounterExportReadsetsResponse++;
-  if (buildCounterExportReadsetsResponse < 3) {
+    unittest.expect(o.projectNumber, unittest.equals('foo'));
+    checkUnnamed1280(o.readGroupSetIds);
+    checkUnnamed1281(o.referenceNames);
+  }
+  buildCounterExportReadGroupSetsRequest--;
+}
+
+core.int buildCounterExportReadGroupSetsResponse = 0;
+buildExportReadGroupSetsResponse() {
+  var o = new api.ExportReadGroupSetsResponse();
+  buildCounterExportReadGroupSetsResponse++;
+  if (buildCounterExportReadGroupSetsResponse < 3) {
     o.jobId = "foo";
   }
-  buildCounterExportReadsetsResponse--;
-  return o;
-}
-
-checkExportReadsetsResponse(api.ExportReadsetsResponse o) {
-  buildCounterExportReadsetsResponse++;
-  if (buildCounterExportReadsetsResponse < 3) {
+  buildCounterExportReadGroupSetsResponse--;
+  return o;
+}
+
+checkExportReadGroupSetsResponse(api.ExportReadGroupSetsResponse o) {
+  buildCounterExportReadGroupSetsResponse++;
+  if (buildCounterExportReadGroupSetsResponse < 3) {
     unittest.expect(o.jobId, unittest.equals('foo'));
   }
-  buildCounterExportReadsetsResponse--;
-}
-
-buildUnnamed1224() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1224(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 buildCounterExportVariantsRequest = 0;
-buildExportVariantsRequest() {
-  var o = new api.ExportVariantsRequest();
-  buildCounterExportVariantsRequest++;
-  if (buildCounterExportVariantsRequest < 3) {
+  buildCounterExportReadGroupSetsResponse--;
+}
+
+buildUnnamed1282() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1282(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 = buildUnnamed1224();
+    o.callSetIds = buildUnnamed1282();
     o.format = "foo";
-    o.projectId = "foo";
-    o.variantSetId = "foo";
-  }
-  buildCounterExportVariantsRequest--;
-  return o;
-}
-
-checkExportVariantsRequest(api.ExportVariantsRequest o) {
-  buildCounterExportVariantsRequest++;
-  if (buildCounterExportVariantsRequest < 3) {
+    o.projectNumber = "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'));
-    checkUnnamed1224(o.callSetIds);
+    checkUnnamed1282(o.callSetIds);
     unittest.expect(o.format, unittest.equals('foo'));
-    unittest.expect(o.projectId, unittest.equals('foo'));
-    unittest.expect(o.variantSetId, unittest.equals('foo'));
-  }
-  buildCounterExportVariantsRequest--;
-}
-
-core.int buildCounterExportVariantsResponse = 0;
-buildExportVariantsResponse() {
-  var o = new api.ExportVariantsResponse();
-  buildCounterExportVariantsResponse++;
-  if (buildCounterExportVariantsResponse < 3) {
+    unittest.expect(o.projectNumber, unittest.equals('foo'));
+  }
+  buildCounterExportVariantSetRequest--;
+}
+
+core.int buildCounterExportVariantSetResponse = 0;
+buildExportVariantSetResponse() {
+  var o = new api.ExportVariantSetResponse();
+  buildCounterExportVariantSetResponse++;
+  if (buildCounterExportVariantSetResponse < 3) {
     o.jobId = "foo";
   }
-  buildCounterExportVariantsResponse--;
-  return o;
-}
-
-checkExportVariantsResponse(api.ExportVariantsResponse o) {
-  buildCounterExportVariantsResponse++;
-  if (buildCounterExportVariantsResponse < 3) {
+  buildCounterExportVariantSetResponse--;
+  return o;
+}
+
+checkExportVariantSetResponse(api.ExportVariantSetResponse o) {
+  buildCounterExportVariantSetResponse++;
+  if (buildCounterExportVariantSetResponse < 3) {
     unittest.expect(o.jobId, unittest.equals('foo'));
   }
-  buildCounterExportVariantsResponse--;
-}
-
-core.int buildCounterGenomicRange = 0;
-buildGenomicRange() {
-  var o = new api.GenomicRange();
-  buildCounterGenomicRange++;
-  if (buildCounterGenomicRange < 3) {
-    o.sequenceEnd = "foo";
-    o.sequenceName = "foo";
-    o.sequenceStart = "foo";
-  }
-  buildCounterGenomicRange--;
-  return o;
-}
-
-checkGenomicRange(api.GenomicRange o) {
-  buildCounterGenomicRange++;
-  if (buildCounterGenomicRange < 3) {
-    unittest.expect(o.sequenceEnd, unittest.equals('foo'));
-    unittest.expect(o.sequenceName, unittest.equals('foo'));
-    unittest.expect(o.sequenceStart, unittest.equals('foo'));
-  }
-  buildCounterGenomicRange--;
-}
-
-core.int buildCounterHeader = 0;
-buildHeader() {
-  var o = new api.Header();
-  buildCounterHeader++;
-  if (buildCounterHeader < 3) {
-    o.sortingOrder = "foo";
-    o.version = "foo";
-  }
-  buildCounterHeader--;
-  return o;
-}
-
-checkHeader(api.Header o) {
-  buildCounterHeader++;
-  if (buildCounterHeader < 3) {
-    unittest.expect(o.sortingOrder, unittest.equals('foo'));
-    unittest.expect(o.version, unittest.equals('foo'));
-  }
-  buildCounterHeader--;
-}
-
-buildUnnamed1225() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1225(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'));
-}
-
-buildUnnamed1226() {
-  var o = new core.List<api.Header>();
-  o.add(buildHeader());
-  o.add(buildHeader());
-  return o;
-}
-
-checkUnnamed1226(core.List<api.Header> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkHeader(o[0]);
-  checkHeader(o[1]);
-}
-
-buildUnnamed1227() {
-  var o = new core.List<api.Program>();
-  o.add(buildProgram());
-  o.add(buildProgram());
-  return o;
-}
-
-checkUnnamed1227(core.List<api.Program> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkProgram(o[0]);
-  checkProgram(o[1]);
-}
-
-buildUnnamed1228() {
-  var o = new core.List<api.ReadGroup>();
-  o.add(buildReadGroup());
-  o.add(buildReadGroup());
-  return o;
-}
-
-checkUnnamed1228(core.List<api.ReadGroup> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkReadGroup(o[0]);
-  checkReadGroup(o[1]);
-}
-
-buildUnnamed1229() {
-  var o = new core.List<api.ReferenceSequence>();
-  o.add(buildReferenceSequence());
-  o.add(buildReferenceSequence());
-  return o;
-}
-
-checkUnnamed1229(core.List<api.ReferenceSequence> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkReferenceSequence(o[0]);
-  checkReferenceSequence(o[1]);
-}
-
-core.int buildCounterHeaderSection = 0;
-buildHeaderSection() {
-  var o = new api.HeaderSection();
-  buildCounterHeaderSection++;
-  if (buildCounterHeaderSection < 3) {
-    o.comments = buildUnnamed1225();
-    o.fileUri = "foo";
-    o.filename = "foo";
-    o.headers = buildUnnamed1226();
-    o.programs = buildUnnamed1227();
-    o.readGroups = buildUnnamed1228();
-    o.refSequences = buildUnnamed1229();
-  }
-  buildCounterHeaderSection--;
-  return o;
-}
-
-checkHeaderSection(api.HeaderSection o) {
-  buildCounterHeaderSection++;
-  if (buildCounterHeaderSection < 3) {
-    checkUnnamed1225(o.comments);
-    unittest.expect(o.fileUri, unittest.equals('foo'));
-    unittest.expect(o.filename, unittest.equals('foo'));
-    checkUnnamed1226(o.headers);
-    checkUnnamed1227(o.programs);
-    checkUnnamed1228(o.readGroups);
-    checkUnnamed1229(o.refSequences);
-  }
-  buildCounterHeaderSection--;
-}
-
-buildUnnamed1230() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1230(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 buildCounterImportReadsetsRequest = 0;
-buildImportReadsetsRequest() {
-  var o = new api.ImportReadsetsRequest();
-  buildCounterImportReadsetsRequest++;
-  if (buildCounterImportReadsetsRequest < 3) {
+  buildCounterExportVariantSetResponse--;
+}
+
+core.int buildCounterFastqMetadata = 0;
+buildFastqMetadata() {
+  var o = new api.FastqMetadata();
+  buildCounterFastqMetadata++;
+  if (buildCounterFastqMetadata < 3) {
+    o.libraryName = "foo";
+    o.platformName = "foo";
+    o.platformUnit = "foo";
+    o.readGroupName = "foo";
+    o.sampleName = "foo";
+  }
+  buildCounterFastqMetadata--;
+  return o;
+}
+
+checkFastqMetadata(api.FastqMetadata o) {
+  buildCounterFastqMetadata++;
+  if (buildCounterFastqMetadata < 3) {
+    unittest.expect(o.libraryName, unittest.equals('foo'));
+    unittest.expect(o.platformName, unittest.equals('foo'));
+    unittest.expect(o.platformUnit, unittest.equals('foo'));
+    unittest.expect(o.readGroupName, unittest.equals('foo'));
+    unittest.expect(o.sampleName, unittest.equals('foo'));
+  }
+  buildCounterFastqMetadata--;
+}
+
+buildUnnamed1283() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1283(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.sourceUris = buildUnnamed1230();
-  }
-  buildCounterImportReadsetsRequest--;
-  return o;
-}
-
-checkImportReadsetsRequest(api.ImportReadsetsRequest o) {
-  buildCounterImportReadsetsRequest++;
-  if (buildCounterImportReadsetsRequest < 3) {
+    o.referenceSetId = "foo";
+    o.sourceUris = buildUnnamed1283();
+  }
+  buildCounterImportReadGroupSetsRequest--;
+  return o;
+}
+
+checkImportReadGroupSetsRequest(api.ImportReadGroupSetsRequest o) {
+  buildCounterImportReadGroupSetsRequest++;
+  if (buildCounterImportReadGroupSetsRequest < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
-    checkUnnamed1230(o.sourceUris);
-  }
-  buildCounterImportReadsetsRequest--;
-}
-
-core.int buildCounterImportReadsetsResponse = 0;
-buildImportReadsetsResponse() {
-  var o = new api.ImportReadsetsResponse();
-  buildCounterImportReadsetsResponse++;
-  if (buildCounterImportReadsetsResponse < 3) {
+    unittest.expect(o.referenceSetId, unittest.equals('foo'));
+    checkUnnamed1283(o.sourceUris);
+  }
+  buildCounterImportReadGroupSetsRequest--;
+}
+
+core.int buildCounterImportReadGroupSetsResponse = 0;
+buildImportReadGroupSetsResponse() {
+  var o = new api.ImportReadGroupSetsResponse();
+  buildCounterImportReadGroupSetsResponse++;
+  if (buildCounterImportReadGroupSetsResponse < 3) {
     o.jobId = "foo";
   }
-  buildCounterImportReadsetsResponse--;
-  return o;
-}
-
-checkImportReadsetsResponse(api.ImportReadsetsResponse o) {
-  buildCounterImportReadsetsResponse++;
-  if (buildCounterImportReadsetsResponse < 3) {
+  buildCounterImportReadGroupSetsResponse--;
+  return o;
+}
+
+checkImportReadGroupSetsResponse(api.ImportReadGroupSetsResponse o) {
+  buildCounterImportReadGroupSetsResponse++;
+  if (buildCounterImportReadGroupSetsResponse < 3) {
     unittest.expect(o.jobId, unittest.equals('foo'));
   }
-  buildCounterImportReadsetsResponse--;
-}
-
-buildUnnamed1231() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1231(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'));
+  buildCounterImportReadGroupSetsResponse--;
+}
+
+buildUnnamed1284() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1284(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.sourceUris = buildUnnamed1231();
-    o.variantSetId = "foo";
+    o.sourceUris = buildUnnamed1284();
   }
   buildCounterImportVariantsRequest--;
   return o;
 }
 
 checkImportVariantsRequest(api.ImportVariantsRequest o) {
   buildCounterImportVariantsRequest++;
   if (buildCounterImportVariantsRequest < 3) {
     unittest.expect(o.format, unittest.equals('foo'));
-    checkUnnamed1231(o.sourceUris);
-    unittest.expect(o.variantSetId, unittest.equals('foo'));
+    checkUnnamed1284(o.sourceUris);
   }
   buildCounterImportVariantsRequest--;
 }
 
 core.int buildCounterImportVariantsResponse = 0;
 buildImportVariantsResponse() {
   var o = new api.ImportVariantsResponse();
   buildCounterImportVariantsResponse++;
   if (buildCounterImportVariantsResponse < 3) {
     o.jobId = "foo";
   }
   buildCounterImportVariantsResponse--;
   return o;
 }
 
 checkImportVariantsResponse(api.ImportVariantsResponse o) {
   buildCounterImportVariantsResponse++;
   if (buildCounterImportVariantsResponse < 3) {
     unittest.expect(o.jobId, unittest.equals('foo'));
   }
   buildCounterImportVariantsResponse--;
 }
 
-buildUnnamed1232() {
+buildUnnamed1285() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1232(core.List<core.String> o) {
+checkUnnamed1285(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'));
 }
 
-buildUnnamed1233() {
+core.int buildCounterInterleavedFastqSource = 0;
+buildInterleavedFastqSource() {
+  var o = new api.InterleavedFastqSource();
+  buildCounterInterleavedFastqSource++;
+  if (buildCounterInterleavedFastqSource < 3) {
+    o.metadata = buildFastqMetadata();
+    o.sourceUris = buildUnnamed1285();
+  }
+  buildCounterInterleavedFastqSource--;
+  return o;
+}
+
+checkInterleavedFastqSource(api.InterleavedFastqSource o) {
+  buildCounterInterleavedFastqSource++;
+  if (buildCounterInterleavedFastqSource < 3) {
+    checkFastqMetadata(o.metadata);
+    checkUnnamed1285(o.sourceUris);
+  }
+  buildCounterInterleavedFastqSource--;
+}
+
+buildUnnamed1286() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1233(core.List<core.String> o) {
+checkUnnamed1286(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'));
 }
 
-buildUnnamed1234() {
+buildUnnamed1287() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1234(core.List<core.String> o) {
+checkUnnamed1287(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'));
+}
+
+buildUnnamed1288() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1288(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 buildCounterJob = 0;
 buildJob() {
   var o = new api.Job();
   buildCounterJob++;
   if (buildCounterJob < 3) {
     o.created = "foo";
-    o.description = "foo";
-    o.errors = buildUnnamed1232();
+    o.detailedStatus = "foo";
+    o.errors = buildUnnamed1286();
     o.id = "foo";
-    o.importedIds = buildUnnamed1233();
-    o.projectId = "foo";
+    o.importedIds = buildUnnamed1287();
+    o.projectNumber = "foo";
     o.request = buildJobRequest();
     o.status = "foo";
-    o.warnings = buildUnnamed1234();
+    o.warnings = buildUnnamed1288();
   }
   buildCounterJob--;
   return o;
 }
 
 checkJob(api.Job o) {
   buildCounterJob++;
   if (buildCounterJob < 3) {
     unittest.expect(o.created, unittest.equals('foo'));
-    unittest.expect(o.description, unittest.equals('foo'));
-    checkUnnamed1232(o.errors);
+    unittest.expect(o.detailedStatus, unittest.equals('foo'));
+    checkUnnamed1286(o.errors);
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1233(o.importedIds);
-    unittest.expect(o.projectId, unittest.equals('foo'));
+    checkUnnamed1287(o.importedIds);
+    unittest.expect(o.projectNumber, unittest.equals('foo'));
     checkJobRequest(o.request);
     unittest.expect(o.status, unittest.equals('foo'));
-    checkUnnamed1234(o.warnings);
+    checkUnnamed1288(o.warnings);
   }
   buildCounterJob--;
 }
 
-buildUnnamed1235() {
+buildUnnamed1289() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1235(core.List<core.String> o) {
+checkUnnamed1289(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'));
 }
 
-buildUnnamed1236() {
+buildUnnamed1290() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1236(core.List<core.String> o) {
+checkUnnamed1290(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 buildCounterJobRequest = 0;
 buildJobRequest() {
   var o = new api.JobRequest();
   buildCounterJobRequest++;
   if (buildCounterJobRequest < 3) {
-    o.destination = buildUnnamed1235();
-    o.source = buildUnnamed1236();
+    o.destination = buildUnnamed1289();
+    o.source = buildUnnamed1290();
     o.type = "foo";
   }
   buildCounterJobRequest--;
   return o;
 }
 
 checkJobRequest(api.JobRequest o) {
   buildCounterJobRequest++;
   if (buildCounterJobRequest < 3) {
-    checkUnnamed1235(o.destination);
-    checkUnnamed1236(o.source);
+    checkUnnamed1289(o.destination);
+    checkUnnamed1290(o.source);
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterJobRequest--;
 }
 
-buildUnnamed1237() {
+buildUnnamed1291() {
+  var o = new core.List<api.CigarUnit>();
+  o.add(buildCigarUnit());
+  o.add(buildCigarUnit());
+  return o;
+}
+
+checkUnnamed1291(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 = buildUnnamed1291();
+    o.mappingQuality = 42;
+    o.position = buildPosition();
+  }
+  buildCounterLinearAlignment--;
+  return o;
+}
+
+checkLinearAlignment(api.LinearAlignment o) {
+  buildCounterLinearAlignment++;
+  if (buildCounterLinearAlignment < 3) {
+    checkUnnamed1291(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--;
+}
+
+buildUnnamed1292() {
   var o = new core.List<api.CoverageBucket>();
   o.add(buildCoverageBucket());
   o.add(buildCoverageBucket());
   return o;
 }
 
-checkUnnamed1237(core.List<api.CoverageBucket> o) {
+checkUnnamed1292(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 = buildUnnamed1237();
+    o.coverageBuckets = buildUnnamed1292();
     o.nextPageToken = "foo";
   }
   buildCounterListCoverageBucketsResponse--;
   return o;
 }
 
 checkListCoverageBucketsResponse(api.ListCoverageBucketsResponse o) {
   buildCounterListCoverageBucketsResponse++;
   if (buildCounterListCoverageBucketsResponse < 3) {
     unittest.expect(o.bucketWidth, unittest.equals('foo'));
-    checkUnnamed1237(o.coverageBuckets);
+    checkUnnamed1292(o.coverageBuckets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListCoverageBucketsResponse--;
 }
 
-buildUnnamed1238() {
+buildUnnamed1293() {
   var o = new core.List<api.Dataset>();
   o.add(buildDataset());
   o.add(buildDataset());
   return o;
 }
 
-checkUnnamed1238(core.List<api.Dataset> o) {
+checkUnnamed1293(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 = buildUnnamed1238();
+    o.datasets = buildUnnamed1293();
     o.nextPageToken = "foo";
   }
   buildCounterListDatasetsResponse--;
   return o;
 }
 
 checkListDatasetsResponse(api.ListDatasetsResponse o) {
   buildCounterListDatasetsResponse++;
   if (buildCounterListDatasetsResponse < 3) {
-    checkUnnamed1238(o.datasets);
+    checkUnnamed1293(o.datasets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListDatasetsResponse--;
 }
 
-buildUnnamed1239() {
+buildUnnamed1294() {
   var o = new core.List<api.Variant>();
   o.add(buildVariant());
   o.add(buildVariant());
   return o;
 }
 
-checkUnnamed1239(core.List<api.Variant> o) {
+checkUnnamed1294(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.variants = buildUnnamed1239();
+    o.variants = buildUnnamed1294();
   }
   buildCounterMergeVariantsRequest--;
   return o;
 }
 
 checkMergeVariantsRequest(api.MergeVariantsRequest o) {
   buildCounterMergeVariantsRequest++;
   if (buildCounterMergeVariantsRequest < 3) {
-    checkUnnamed1239(o.variants);
+    checkUnnamed1294(o.variants);
   }
   buildCounterMergeVariantsRequest--;
 }
 
-buildUnnamed1240() {
+buildUnnamed1295() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1240(core.List<core.String> o) {
+checkUnnamed1295(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'));
 }
 
-buildUnnamed1241() {
+buildUnnamed1296() {
   var o = new core.Map<core.String, core.List<core.String>>();
-  o["x"] = buildUnnamed1240();
-  o["y"] = buildUnnamed1240();
+  o["x"] = buildUnnamed1295();
+  o["y"] = buildUnnamed1295();
   return o;
 }
 
-checkUnnamed1241(core.Map<core.String, core.List<core.String>> o) {
+checkUnnamed1296(core.Map<core.String, core.List<core.String>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1240(o["x"]);
-  checkUnnamed1240(o["y"]);
+  checkUnnamed1295(o["x"]);
+  checkUnnamed1295(o["y"]);
 }
 
 core.int buildCounterMetadata = 0;
 buildMetadata() {
   var o = new api.Metadata();
   buildCounterMetadata++;
   if (buildCounterMetadata < 3) {
     o.description = "foo";
     o.id = "foo";
-    o.info = buildUnnamed1241();
+    o.info = buildUnnamed1296();
     o.key = "foo";
     o.number = "foo";
     o.type = "foo";
     o.value = "foo";
   }
   buildCounterMetadata--;
   return o;
 }
 
 checkMetadata(api.Metadata o) {
   buildCounterMetadata++;
   if (buildCounterMetadata < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1241(o.info);
+    checkUnnamed1296(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'));
   }
   buildCounterMetadata--;
 }
 
-core.int buildCounterProgram = 0;
-buildProgram() {
-  var o = new api.Program();
-  buildCounterProgram++;
-  if (buildCounterProgram < 3) {
-    o.commandLine = "foo";
-    o.id = "foo";
-    o.name = "foo";
-    o.prevProgramId = "foo";
-    o.version = "foo";
-  }
-  buildCounterProgram--;
-  return o;
-}
-
-checkProgram(api.Program o) {
-  buildCounterProgram++;
-  if (buildCounterProgram < 3) {
-    unittest.expect(o.commandLine, unittest.equals('foo'));
-    unittest.expect(o.id, unittest.equals('foo'));
-    unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.prevProgramId, unittest.equals('foo'));
-    unittest.expect(o.version, unittest.equals('foo'));
-  }
-  buildCounterProgram--;
-}
-
-buildUnnamed1242() {
+buildUnnamed1297() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1242(core.List<core.String> o) {
+checkUnnamed1297(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'));
 }
 
-buildUnnamed1243() {
-  var o = new core.Map<core.String, core.List<core.String>>();
-  o["x"] = buildUnnamed1242();
-  o["y"] = buildUnnamed1242();
+buildUnnamed1298() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
   return o;
 }
 
-checkUnnamed1243(core.Map<core.String, core.List<core.String>> o) {
+checkUnnamed1298(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1242(o["x"]);
-  checkUnnamed1242(o["y"]);
+  unittest.expect(o[0], unittest.equals('foo'));
+  unittest.expect(o[1], unittest.equals('foo'));
+}
+
+core.int buildCounterPairedFastqSource = 0;
+buildPairedFastqSource() {
+  var o = new api.PairedFastqSource();
+  buildCounterPairedFastqSource++;
+  if (buildCounterPairedFastqSource < 3) {
+    o.firstSourceUris = buildUnnamed1297();
+    o.metadata = buildFastqMetadata();
+    o.secondSourceUris = buildUnnamed1298();
+  }
+  buildCounterPairedFastqSource--;
+  return o;
+}
+
+checkPairedFastqSource(api.PairedFastqSource o) {
+  buildCounterPairedFastqSource++;
+  if (buildCounterPairedFastqSource < 3) {
+    checkUnnamed1297(o.firstSourceUris);
+    checkFastqMetadata(o.metadata);
+    checkUnnamed1298(o.secondSourceUris);
+  }
+  buildCounterPairedFastqSource--;
+}
+
+core.int buildCounterPosition = 0;
+buildPosition() {
+  var o = new api.Position();
+  buildCounterPosition++;
+  if (buildCounterPosition < 3) {
+    o.position = "foo";
+    o.referenceName = "foo";
+    o.reverseStrand = true;
+  }
+  buildCounterPosition--;
+  return o;
+}
+
+checkPosition(api.Position o) {
+  buildCounterPosition++;
+  if (buildCounterPosition < 3) {
+    unittest.expect(o.position, unittest.equals('foo'));
+    unittest.expect(o.referenceName, unittest.equals('foo'));
+    unittest.expect(o.reverseStrand, unittest.isTrue);
+  }
+  buildCounterPosition--;
+}
+
+core.int buildCounterRange = 0;
+buildRange() {
+  var o = new api.Range();
+  buildCounterRange++;
+  if (buildCounterRange < 3) {
+    o.end = "foo";
+    o.referenceName = "foo";
+    o.start = "foo";
+  }
+  buildCounterRange--;
+  return o;
+}
+
+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--;
+}
+
+buildUnnamed1299() {
+  var o = new core.List<core.int>();
+  o.add(42);
+  o.add(42);
+  return o;
+}
+
+checkUnnamed1299(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));
+}
+
+buildUnnamed1300() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1300(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'));
+}
+
+buildUnnamed1301() {
+  var o = new core.Map<core.String, core.List<core.String>>();
+  o["x"] = buildUnnamed1300();
+  o["y"] = buildUnnamed1300();
+  return o;
+}
+
+checkUnnamed1301(core.Map<core.String, core.List<core.String>> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUnnamed1300(o["x"]);
+  checkUnnamed1300(o["y"]);
 }
 
 core.int buildCounterRead = 0;
 buildRead() {
   var o = new api.Read();
   buildCounterRead++;
   if (buildCounterRead < 3) {
-    o.alignedBases = "foo";
-    o.baseQuality = "foo";
-    o.cigar = "foo";
-    o.flags = 42;
+    o.alignedQuality = buildUnnamed1299();
+    o.alignedSequence = "foo";
+    o.alignment = buildLinearAlignment();
+    o.duplicateFragment = true;
+    o.failedVendorQualityChecks = true;
+    o.fragmentLength = 42;
+    o.fragmentName = "foo";
     o.id = "foo";
-    o.mappingQuality = 42;
-    o.matePosition = 42;
-    o.mateReferenceSequenceName = "foo";
-    o.name = "foo";
-    o.originalBases = "foo";
-    o.position = 42;
-    o.readsetId = "foo";
-    o.referenceSequenceName = "foo";
-    o.tags = buildUnnamed1243();
-    o.templateLength = 42;
+    o.info = buildUnnamed1301();
+    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) {
-    unittest.expect(o.alignedBases, unittest.equals('foo'));
-    unittest.expect(o.baseQuality, unittest.equals('foo'));
-    unittest.expect(o.cigar, unittest.equals('foo'));
-    unittest.expect(o.flags, unittest.equals(42));
+    checkUnnamed1299(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'));
-    unittest.expect(o.mappingQuality, unittest.equals(42));
-    unittest.expect(o.matePosition, unittest.equals(42));
-    unittest.expect(o.mateReferenceSequenceName, unittest.equals('foo'));
-    unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.originalBases, unittest.equals('foo'));
-    unittest.expect(o.position, unittest.equals(42));
-    unittest.expect(o.readsetId, unittest.equals('foo'));
-    unittest.expect(o.referenceSequenceName, unittest.equals('foo'));
-    checkUnnamed1243(o.tags);
-    unittest.expect(o.templateLength, unittest.equals(42));
+    checkUnnamed1301(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--;
 }
 
+buildUnnamed1302() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1302(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'));
+}
+
+buildUnnamed1303() {
+  var o = new core.Map<core.String, core.List<core.String>>();
+  o["x"] = buildUnnamed1302();
+  o["y"] = buildUnnamed1302();
+  return o;
+}
+
+checkUnnamed1303(core.Map<core.String, core.List<core.String>> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUnnamed1302(o["x"]);
+  checkUnnamed1302(o["y"]);
+}
+
+buildUnnamed1304() {
+  var o = new core.List<api.ReadGroupProgram>();
+  o.add(buildReadGroupProgram());
+  o.add(buildReadGroupProgram());
+  return o;
+}
+
+checkUnnamed1304(core.List<api.ReadGroupProgram> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkReadGroupProgram(o[0]);
+  checkReadGroupProgram(o[1]);
+}
+
 core.int buildCounterReadGroup = 0;
 buildReadGroup() {
   var o = new api.ReadGroup();
   buildCounterReadGroup++;
   if (buildCounterReadGroup < 3) {
-    o.date = "foo";
+    o.datasetId = "foo";
     o.description = "foo";
-    o.flowOrder = "foo";
+    o.experiment = buildReadGroupExperiment();
     o.id = "foo";
-    o.keySequence = "foo";
-    o.library = "foo";
-    o.platformUnit = "foo";
+    o.info = buildUnnamed1303();
+    o.name = "foo";
     o.predictedInsertSize = 42;
-    o.processingProgram = "foo";
-    o.sample = "foo";
-    o.sequencingCenterName = "foo";
-    o.sequencingTechnology = "foo";
+    o.programs = buildUnnamed1304();
+    o.referenceSetId = "foo";
+    o.sampleId = "foo";
   }
   buildCounterReadGroup--;
   return o;
 }
 
 checkReadGroup(api.ReadGroup o) {
   buildCounterReadGroup++;
   if (buildCounterReadGroup < 3) {
-    unittest.expect(o.date, unittest.equals('foo'));
+    unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
-    unittest.expect(o.flowOrder, unittest.equals('foo'));
+    checkReadGroupExperiment(o.experiment);
     unittest.expect(o.id, unittest.equals('foo'));
-    unittest.expect(o.keySequence, unittest.equals('foo'));
-    unittest.expect(o.library, unittest.equals('foo'));
-    unittest.expect(o.platformUnit, unittest.equals('foo'));
+    checkUnnamed1303(o.info);
+    unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.predictedInsertSize, unittest.equals(42));
-    unittest.expect(o.processingProgram, unittest.equals('foo'));
-    unittest.expect(o.sample, unittest.equals('foo'));
-    unittest.expect(o.sequencingCenterName, unittest.equals('foo'));
-    unittest.expect(o.sequencingTechnology, unittest.equals('foo'));
+    checkUnnamed1304(o.programs);
+    unittest.expect(o.referenceSetId, unittest.equals('foo'));
+    unittest.expect(o.sampleId, unittest.equals('foo'));
   }
   buildCounterReadGroup--;
 }
 
-buildUnnamed1244() {
-  var o = new core.List<api.HeaderSection>();
-  o.add(buildHeaderSection());
-  o.add(buildHeaderSection());
+core.int buildCounterReadGroupExperiment = 0;
+buildReadGroupExperiment() {
+  var o = new api.ReadGroupExperiment();
+  buildCounterReadGroupExperiment++;
+  if (buildCounterReadGroupExperiment < 3) {
+    o.instrumentModel = "foo";
+    o.libraryId = "foo";
+    o.platformUnit = "foo";
+    o.sequencingCenter = "foo";
+  }
+  buildCounterReadGroupExperiment--;
   return o;
 }
 
-checkUnnamed1244(core.List<api.HeaderSection> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkHeaderSection(o[0]);
-  checkHeaderSection(o[1]);
+checkReadGroupExperiment(api.ReadGroupExperiment o) {
+  buildCounterReadGroupExperiment++;
+  if (buildCounterReadGroupExperiment < 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'));
+  }
+  buildCounterReadGroupExperiment--;
 }
 
-core.int buildCounterReadset = 0;
-buildReadset() {
-  var o = new api.Readset();
-  buildCounterReadset++;
-  if (buildCounterReadset < 3) {
-    o.datasetId = "foo";
-    o.fileData = buildUnnamed1244();
+core.int buildCounterReadGroupProgram = 0;
+buildReadGroupProgram() {
+  var o = new api.ReadGroupProgram();
+  buildCounterReadGroupProgram++;
+  if (buildCounterReadGroupProgram < 3) {
+    o.commandLine = "foo";
     o.id = "foo";
     o.name = "foo";
+    o.prevProgramId = "foo";
+    o.version = "foo";
   }
-  buildCounterReadset--;
+  buildCounterReadGroupProgram--;
   return o;
 }
 
-checkReadset(api.Readset o) {
-  buildCounterReadset++;
-  if (buildCounterReadset < 3) {
-    unittest.expect(o.datasetId, unittest.equals('foo'));
-    checkUnnamed1244(o.fileData);
+checkReadGroupProgram(api.ReadGroupProgram o) {
+  buildCounterReadGroupProgram++;
+  if (buildCounterReadGroupProgram < 3) {
+    unittest.expect(o.commandLine, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.prevProgramId, unittest.equals('foo'));
+    unittest.expect(o.version, unittest.equals('foo'));
   }
-  buildCounterReadset--;
+  buildCounterReadGroupProgram--;
+}
+
+buildUnnamed1305() {
+  var o = new core.List<api.ReadGroup>();
+  o.add(buildReadGroup());
+  o.add(buildReadGroup());
+  return o;
+}
+
+checkUnnamed1305(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.name = "foo";
+    o.readGroups = buildUnnamed1305();
+    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'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed1305(o.readGroups);
+    unittest.expect(o.referenceSetId, unittest.equals('foo'));
+  }
+  buildCounterReadGroupSet--;
+}
+
+buildUnnamed1306() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1306(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 = buildUnnamed1306();
+    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));
+    checkUnnamed1306(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--;
 }
 
-core.int buildCounterReferenceSequence = 0;
-buildReferenceSequence() {
-  var o = new api.ReferenceSequence();
-  buildCounterReferenceSequence++;
-  if (buildCounterReferenceSequence < 3) {
-    o.assemblyId = "foo";
-    o.length = 42;
-    o.md5Checksum = "foo";
-    o.name = "foo";
-    o.species = "foo";
-    o.uri = "foo";
-  }
-  buildCounterReferenceSequence--;
-  return o;
-}
-
-checkReferenceSequence(api.ReferenceSequence o) {
-  buildCounterReferenceSequence++;
-  if (buildCounterReferenceSequence < 3) {
-    unittest.expect(o.assemblyId, unittest.equals('foo'));
-    unittest.expect(o.length, unittest.equals(42));
-    unittest.expect(o.md5Checksum, unittest.equals('foo'));
-    unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.species, unittest.equals('foo'));
-    unittest.expect(o.uri, unittest.equals('foo'));
-  }
-  buildCounterReferenceSequence--;
-}
-
-buildUnnamed1245() {
+buildUnnamed1307() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1245(core.List<core.String> o) {
+checkUnnamed1307(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'));
+}
+
+buildUnnamed1308() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1308(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 = buildUnnamed1307();
+    o.sourceAccessions = buildUnnamed1308();
+    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));
+    checkUnnamed1307(o.referenceIds);
+    checkUnnamed1308(o.sourceAccessions);
+    unittest.expect(o.sourceURI, unittest.equals('foo'));
+  }
+  buildCounterReferenceSet--;
+}
+
+buildUnnamed1309() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1309(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 = buildUnnamed1245();
+    o.variantSetIds = buildUnnamed1309();
   }
   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'));
-    checkUnnamed1245(o.variantSetIds);
+    checkUnnamed1309(o.variantSetIds);
   }
   buildCounterSearchCallSetsRequest--;
 }
 
-buildUnnamed1246() {
+buildUnnamed1310() {
   var o = new core.List<api.CallSet>();
   o.add(buildCallSet());
   o.add(buildCallSet());
   return o;
 }
 
-checkUnnamed1246(core.List<api.CallSet> o) {
+checkUnnamed1310(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 = buildUnnamed1246();
+    o.callSets = buildUnnamed1310();
     o.nextPageToken = "foo";
   }
   buildCounterSearchCallSetsResponse--;
   return o;
 }
 
 checkSearchCallSetsResponse(api.SearchCallSetsResponse o) {
   buildCounterSearchCallSetsResponse++;
   if (buildCounterSearchCallSetsResponse < 3) {
-    checkUnnamed1246(o.callSets);
+    checkUnnamed1310(o.callSets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchCallSetsResponse--;
 }
 
-buildUnnamed1247() {
+buildUnnamed1311() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1247(core.List<core.String> o) {
+checkUnnamed1311(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 buildCounterSearchJobsRequest = 0;
 buildSearchJobsRequest() {
   var o = new api.SearchJobsRequest();
   buildCounterSearchJobsRequest++;
   if (buildCounterSearchJobsRequest < 3) {
     o.createdAfter = "foo";
     o.createdBefore = "foo";
-    o.maxResults = "foo";
+    o.pageSize = 42;
     o.pageToken = "foo";
-    o.projectId = "foo";
-    o.status = buildUnnamed1247();
+    o.projectNumber = "foo";
+    o.status = buildUnnamed1311();
   }
   buildCounterSearchJobsRequest--;
   return o;
 }
 
 checkSearchJobsRequest(api.SearchJobsRequest o) {
   buildCounterSearchJobsRequest++;
   if (buildCounterSearchJobsRequest < 3) {
     unittest.expect(o.createdAfter, unittest.equals('foo'));
     unittest.expect(o.createdBefore, unittest.equals('foo'));
-    unittest.expect(o.maxResults, unittest.equals('foo'));
+    unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
-    unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed1247(o.status);
+    unittest.expect(o.projectNumber, unittest.equals('foo'));
+    checkUnnamed1311(o.status);
   }
   buildCounterSearchJobsRequest--;
 }
 
-buildUnnamed1248() {
+buildUnnamed1312() {
   var o = new core.List<api.Job>();
   o.add(buildJob());
   o.add(buildJob());
   return o;
 }
 
-checkUnnamed1248(core.List<api.Job> o) {
+checkUnnamed1312(core.List<api.Job> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkJob(o[0]);
   checkJob(o[1]);
 }
 
 core.int buildCounterSearchJobsResponse = 0;
 buildSearchJobsResponse() {
   var o = new api.SearchJobsResponse();
   buildCounterSearchJobsResponse++;
   if (buildCounterSearchJobsResponse < 3) {
-    o.jobs = buildUnnamed1248();
+    o.jobs = buildUnnamed1312();
     o.nextPageToken = "foo";
   }
   buildCounterSearchJobsResponse--;
   return o;
 }
 
 checkSearchJobsResponse(api.SearchJobsResponse o) {
   buildCounterSearchJobsResponse++;
   if (buildCounterSearchJobsResponse < 3) {
-    checkUnnamed1248(o.jobs);
+    checkUnnamed1312(o.jobs);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchJobsResponse--;
 }
 
-buildUnnamed1249() {
+buildUnnamed1313() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1249(core.List<core.String> o) {
+checkUnnamed1313(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 = buildUnnamed1313();
+    o.name = "foo";
+    o.pageSize = 42;
+    o.pageToken = "foo";
+  }
+  buildCounterSearchReadGroupSetsRequest--;
+  return o;
+}
+
+checkSearchReadGroupSetsRequest(api.SearchReadGroupSetsRequest o) {
+  buildCounterSearchReadGroupSetsRequest++;
+  if (buildCounterSearchReadGroupSetsRequest < 3) {
+    checkUnnamed1313(o.datasetIds);
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.pageSize, unittest.equals(42));
+    unittest.expect(o.pageToken, unittest.equals('foo'));
+  }
+  buildCounterSearchReadGroupSetsRequest--;
+}
+
+buildUnnamed1314() {
+  var o = new core.List<api.ReadGroupSet>();
+  o.add(buildReadGroupSet());
+  o.add(buildReadGroupSet());
+  return o;
+}
+
+checkUnnamed1314(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 = buildUnnamed1314();
+  }
+  buildCounterSearchReadGroupSetsResponse--;
+  return o;
+}
+
+checkSearchReadGroupSetsResponse(api.SearchReadGroupSetsResponse o) {
+  buildCounterSearchReadGroupSetsResponse++;
+  if (buildCounterSearchReadGroupSetsResponse < 3) {
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    checkUnnamed1314(o.readGroupSets);
+  }
+  buildCounterSearchReadGroupSetsResponse--;
+}
+
+buildUnnamed1315() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1315(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'));
+}
+
+buildUnnamed1316() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1316(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.maxResults = "foo";
+    o.end = "foo";
+    o.pageSize = 42;
     o.pageToken = "foo";
-    o.readsetIds = buildUnnamed1249();
-    o.sequenceEnd = "foo";
-    o.sequenceName = "foo";
-    o.sequenceStart = "foo";
+    o.readGroupIds = buildUnnamed1315();
+    o.readGroupSetIds = buildUnnamed1316();
+    o.referenceName = "foo";
+    o.start = "foo";
   }
   buildCounterSearchReadsRequest--;
   return o;
 }
 
 checkSearchReadsRequest(api.SearchReadsRequest o) {
   buildCounterSearchReadsRequest++;
   if (buildCounterSearchReadsRequest < 3) {
-    unittest.expect(o.maxResults, unittest.equals('foo'));
+    unittest.expect(o.end, unittest.equals('foo'));
+    unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
-    checkUnnamed1249(o.readsetIds);
-    unittest.expect(o.sequenceEnd, unittest.equals('foo'));
-    unittest.expect(o.sequenceName, unittest.equals('foo'));
-    unittest.expect(o.sequenceStart, unittest.equals('foo'));
+    checkUnnamed1315(o.readGroupIds);
+    checkUnnamed1316(o.readGroupSetIds);
+    unittest.expect(o.referenceName, unittest.equals('foo'));
+    unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterSearchReadsRequest--;
 }
 
-buildUnnamed1250() {
+buildUnnamed1317() {
   var o = new core.List<api.Read>();
   o.add(buildRead());
   o.add(buildRead());
   return o;
 }
 
-checkUnnamed1250(core.List<api.Read> o) {
+checkUnnamed1317(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 = buildUnnamed1317();
     o.nextPageToken = "foo";
-    o.reads = buildUnnamed1250();
   }
   buildCounterSearchReadsResponse--;
   return o;
 }
 
 checkSearchReadsResponse(api.SearchReadsResponse o) {
   buildCounterSearchReadsResponse++;
   if (buildCounterSearchReadsResponse < 3) {
+    checkUnnamed1317(o.alignments);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1250(o.reads);
   }
   buildCounterSearchReadsResponse--;
 }
 
-buildUnnamed1251() {
+buildUnnamed1318() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1251(core.List<core.String> o) {
+checkUnnamed1318(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 buildCounterSearchReadsetsRequest = 0;
-buildSearchReadsetsRequest() {
-  var o = new api.SearchReadsetsRequest();
-  buildCounterSearchReadsetsRequest++;
-  if (buildCounterSearchReadsetsRequest < 3) {
-    o.datasetIds = buildUnnamed1251();
-    o.maxResults = "foo";
-    o.name = "foo";
-    o.pageToken = "foo";
-  }
-  buildCounterSearchReadsetsRequest--;
-  return o;
-}
-
-checkSearchReadsetsRequest(api.SearchReadsetsRequest o) {
-  buildCounterSearchReadsetsRequest++;
-  if (buildCounterSearchReadsetsRequest < 3) {
-    checkUnnamed1251(o.datasetIds);
-    unittest.expect(o.maxResults, unittest.equals('foo'));
-    unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.pageToken, unittest.equals('foo'));
-  }
-  buildCounterSearchReadsetsRequest--;
-}
-
-buildUnnamed1252() {
-  var o = new core.List<api.Readset>();
-  o.add(buildReadset());
-  o.add(buildReadset());
-  return o;
-}
-
-checkUnnamed1252(core.List<api.Readset> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkReadset(o[0]);
-  checkReadset(o[1]);
-}
-
-core.int buildCounterSearchReadsetsResponse = 0;
-buildSearchReadsetsResponse() {
-  var o = new api.SearchReadsetsResponse();
-  buildCounterSearchReadsetsResponse++;
-  if (buildCounterSearchReadsetsResponse < 3) {
-    o.nextPageToken = "foo";
-    o.readsets = buildUnnamed1252();
-  }
-  buildCounterSearchReadsetsResponse--;
-  return o;
-}
-
-checkSearchReadsetsResponse(api.SearchReadsetsResponse o) {
-  buildCounterSearchReadsetsResponse++;
-  if (buildCounterSearchReadsetsResponse < 3) {
-    unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1252(o.readsets);
-  }
-  buildCounterSearchReadsetsResponse--;
-}
-
-buildUnnamed1253() {
+buildUnnamed1319() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1253(core.List<core.String> o) {
+checkUnnamed1319(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 = buildUnnamed1318();
+    o.md5checksums = buildUnnamed1319();
+    o.pageSize = 42;
+    o.pageToken = "foo";
+  }
+  buildCounterSearchReferenceSetsRequest--;
+  return o;
+}
+
+checkSearchReferenceSetsRequest(api.SearchReferenceSetsRequest o) {
+  buildCounterSearchReferenceSetsRequest++;
+  if (buildCounterSearchReferenceSetsRequest < 3) {
+    checkUnnamed1318(o.accessions);
+    checkUnnamed1319(o.md5checksums);
+    unittest.expect(o.pageSize, unittest.equals(42));
+    unittest.expect(o.pageToken, unittest.equals('foo'));
+  }
+  buildCounterSearchReferenceSetsRequest--;
+}
+
+buildUnnamed1320() {
+  var o = new core.List<api.ReferenceSet>();
+  o.add(buildReferenceSet());
+  o.add(buildReferenceSet());
+  return o;
+}
+
+checkUnnamed1320(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 = buildUnnamed1320();
+  }
+  buildCounterSearchReferenceSetsResponse--;
+  return o;
+}
+
+checkSearchReferenceSetsResponse(api.SearchReferenceSetsResponse o) {
+  buildCounterSearchReferenceSetsResponse++;
+  if (buildCounterSearchReferenceSetsResponse < 3) {
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    checkUnnamed1320(o.referenceSets);
+  }
+  buildCounterSearchReferenceSetsResponse--;
+}
+
+buildUnnamed1321() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1321(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'));
+}
+
+buildUnnamed1322() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1322(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 = buildUnnamed1321();
+    o.md5checksums = buildUnnamed1322();
+    o.pageSize = 42;
+    o.pageToken = "foo";
+    o.referenceSetId = "foo";
+  }
+  buildCounterSearchReferencesRequest--;
+  return o;
+}
+
+checkSearchReferencesRequest(api.SearchReferencesRequest o) {
+  buildCounterSearchReferencesRequest++;
+  if (buildCounterSearchReferencesRequest < 3) {
+    checkUnnamed1321(o.accessions);
+    checkUnnamed1322(o.md5checksums);
+    unittest.expect(o.pageSize, unittest.equals(42));
+    unittest.expect(o.pageToken, unittest.equals('foo'));
+    unittest.expect(o.referenceSetId, unittest.equals('foo'));
+  }
+  buildCounterSearchReferencesRequest--;
+}
+
+buildUnnamed1323() {
+  var o = new core.List<api.Reference>();
+  o.add(buildReference());
+  o.add(buildReference());
+  return o;
+}
+
+checkUnnamed1323(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 = buildUnnamed1323();
+  }
+  buildCounterSearchReferencesResponse--;
+  return o;
+}
+
+checkSearchReferencesResponse(api.SearchReferencesResponse o) {
+  buildCounterSearchReferencesResponse++;
+  if (buildCounterSearchReferencesResponse < 3) {
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    checkUnnamed1323(o.references);
+  }
+  buildCounterSearchReferencesResponse--;
+}
+
+buildUnnamed1324() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1324(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 = buildUnnamed1253();
+    o.datasetIds = buildUnnamed1324();
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchVariantSetsRequest--;
   return o;
 }
 
 checkSearchVariantSetsRequest(api.SearchVariantSetsRequest o) {
   buildCounterSearchVariantSetsRequest++;
   if (buildCounterSearchVariantSetsRequest < 3) {
-    checkUnnamed1253(o.datasetIds);
+    checkUnnamed1324(o.datasetIds);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchVariantSetsRequest--;
 }
 
-buildUnnamed1254() {
+buildUnnamed1325() {
   var o = new core.List<api.VariantSet>();
   o.add(buildVariantSet());
   o.add(buildVariantSet());
   return o;
 }
 
-checkUnnamed1254(core.List<api.VariantSet> o) {
+checkUnnamed1325(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 = buildUnnamed1254();
+    o.variantSets = buildUnnamed1325();
   }
   buildCounterSearchVariantSetsResponse--;
   return o;
 }
 
 checkSearchVariantSetsResponse(api.SearchVariantSetsResponse o) {
   buildCounterSearchVariantSetsResponse++;
   if (buildCounterSearchVariantSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1254(o.variantSets);
+    checkUnnamed1325(o.variantSets);
   }
   buildCounterSearchVariantSetsResponse--;
 }
 
-buildUnnamed1255() {
+buildUnnamed1326() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1255(core.List<core.String> o) {
+checkUnnamed1326(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'));
 }
 
-buildUnnamed1256() {
+buildUnnamed1327() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1256(core.List<core.String> o) {
+checkUnnamed1327(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 = buildUnnamed1255();
+    o.callSetIds = buildUnnamed1326();
     o.end = "foo";
     o.maxCalls = 42;
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceName = "foo";
     o.start = "foo";
     o.variantName = "foo";
-    o.variantSetIds = buildUnnamed1256();
+    o.variantSetIds = buildUnnamed1327();
   }
   buildCounterSearchVariantsRequest--;
   return o;
 }
 
 checkSearchVariantsRequest(api.SearchVariantsRequest o) {
   buildCounterSearchVariantsRequest++;
   if (buildCounterSearchVariantsRequest < 3) {
-    checkUnnamed1255(o.callSetIds);
+    checkUnnamed1326(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'));
-    checkUnnamed1256(o.variantSetIds);
+    checkUnnamed1327(o.variantSetIds);
   }
   buildCounterSearchVariantsRequest--;
 }
 
-buildUnnamed1257() {
+buildUnnamed1328() {
   var o = new core.List<api.Variant>();
   o.add(buildVariant());
   o.add(buildVariant());
   return o;
 }
 
-checkUnnamed1257(core.List<api.Variant> o) {
+checkUnnamed1328(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 = buildUnnamed1257();
+    o.variants = buildUnnamed1328();
   }
   buildCounterSearchVariantsResponse--;
   return o;
 }
 
 checkSearchVariantsResponse(api.SearchVariantsResponse o) {
   buildCounterSearchVariantsResponse++;
   if (buildCounterSearchVariantsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1257(o.variants);
+    checkUnnamed1328(o.variants);
   }
   buildCounterSearchVariantsResponse--;
 }
 
-buildUnnamed1258() {
+buildUnnamed1329() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1258(core.List<core.String> o) {
+checkUnnamed1329(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'));
 }
 
-buildUnnamed1259() {
+buildUnnamed1330() {
   var o = new core.List<api.Call>();
   o.add(buildCall());
   o.add(buildCall());
   return o;
 }
 
-checkUnnamed1259(core.List<api.Call> o) {
+checkUnnamed1330(core.List<api.Call> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCall(o[0]);
   checkCall(o[1]);
 }
 
-buildUnnamed1260() {
+buildUnnamed1331() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1260(core.List<core.String> o) {
+checkUnnamed1331(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'));
 }
 
-buildUnnamed1261() {
+buildUnnamed1332() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1261(core.List<core.String> o) {
+checkUnnamed1332(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'));
 }
 
-buildUnnamed1262() {
+buildUnnamed1333() {
   var o = new core.Map<core.String, core.List<core.String>>();
-  o["x"] = buildUnnamed1261();
-  o["y"] = buildUnnamed1261();
+  o["x"] = buildUnnamed1332();
+  o["y"] = buildUnnamed1332();
   return o;
 }
 
-checkUnnamed1262(core.Map<core.String, core.List<core.String>> o) {
+checkUnnamed1333(core.Map<core.String, core.List<core.String>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1261(o["x"]);
-  checkUnnamed1261(o["y"]);
+  checkUnnamed1332(o["x"]);
+  checkUnnamed1332(o["y"]);
 }
 
-buildUnnamed1263() {
+buildUnnamed1334() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1263(core.List<core.String> o) {
+checkUnnamed1334(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 = buildUnnamed1258();
-    o.calls = buildUnnamed1259();
+    o.alternateBases = buildUnnamed1329();
+    o.calls = buildUnnamed1330();
     o.created = "foo";
     o.end = "foo";
-    o.filter = buildUnnamed1260();
+    o.filter = buildUnnamed1331();
     o.id = "foo";
-    o.info = buildUnnamed1262();
-    o.names = buildUnnamed1263();
+    o.info = buildUnnamed1333();
+    o.names = buildUnnamed1334();
     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) {
-    checkUnnamed1258(o.alternateBases);
-    checkUnnamed1259(o.calls);
+    checkUnnamed1329(o.alternateBases);
+    checkUnnamed1330(o.calls);
     unittest.expect(o.created, unittest.equals('foo'));
     unittest.expect(o.end, unittest.equals('foo'));
-    checkUnnamed1260(o.filter);
+    checkUnnamed1331(o.filter);
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1262(o.info);
-    checkUnnamed1263(o.names);
+    checkUnnamed1333(o.info);
+    checkUnnamed1334(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--;
 }
 
-buildUnnamed1264() {
+buildUnnamed1335() {
   var o = new core.List<api.Metadata>();
   o.add(buildMetadata());
   o.add(buildMetadata());
   return o;
 }
 
-checkUnnamed1264(core.List<api.Metadata> o) {
+checkUnnamed1335(core.List<api.Metadata> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetadata(o[0]);
   checkMetadata(o[1]);
 }
 
-buildUnnamed1265() {
+buildUnnamed1336() {
   var o = new core.List<api.ReferenceBound>();
   o.add(buildReferenceBound());
   o.add(buildReferenceBound());
   return o;
 }
 
-checkUnnamed1265(core.List<api.ReferenceBound> o) {
+checkUnnamed1336(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.id = "foo";
-    o.metadata = buildUnnamed1264();
-    o.referenceBounds = buildUnnamed1265();
+    o.metadata = buildUnnamed1335();
+    o.referenceBounds = buildUnnamed1336();
   }
   buildCounterVariantSet--;
   return o;
 }
 
 checkVariantSet(api.VariantSet o) {
   buildCounterVariantSet++;
   if (buildCounterVariantSet < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1264(o.metadata);
-    checkUnnamed1265(o.referenceBounds);
+    checkUnnamed1335(o.metadata);
+    checkUnnamed1336(o.referenceBounds);
   }
   buildCounterVariantSet--;
 }
 
 
 main() {
-  unittest.group("obj-schema-Beacon", () {
+  unittest.group("obj-schema-AlignReadGroupSetsRequest", () {
     unittest.test("to-json--from-json", () {
-      var o = buildBeacon();
-      var od = new api.Beacon.fromJson(o.toJson());
-      checkBeacon(od);
+      var o = buildAlignReadGroupSetsRequest();
+      var od = new api.AlignReadGroupSetsRequest.fromJson(o.toJson());
+      checkAlignReadGroupSetsRequest(od);
     });
   });
 
+
+  unittest.group("obj-schema-AlignReadGroupSetsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAlignReadGroupSetsResponse();
+      var od = new api.AlignReadGroupSetsResponse.fromJson(o.toJson());
+      checkAlignReadGroupSetsResponse(od);
+    });
+  });
+
 
   unittest.group("obj-schema-Call", () {
     unittest.test("to-json--from-json", () {
       var o = buildCall();
       var od = new api.Call.fromJson(o.toJson());
       checkCall(od);
     });
   });
 
 
+  unittest.group("obj-schema-CallReadGroupSetsRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCallReadGroupSetsRequest();
+      var od = new api.CallReadGroupSetsRequest.fromJson(o.toJson());
+      checkCallReadGroupSetsRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-CallReadGroupSetsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCallReadGroupSetsResponse();
+      var od = new api.CallReadGroupSetsResponse.fromJson(o.toJson());
+      checkCallReadGroupSetsResponse(od);
+    });
+  });
+
+
   unittest.group("obj-schema-CallSet", () {
     unittest.test("to-json--from-json", () {
       var o = buildCallSet();
       var od = new api.CallSet.fromJson(o.toJson());
       checkCallSet(od);
     });
   });
 
 
+  unittest.group("obj-schema-CigarUnit", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCigarUnit();
+      var od = new api.CigarUnit.fromJson(o.toJson());
+      checkCigarUnit(od);
+    });
+  });
+
+
   unittest.group("obj-schema-CoverageBucket", () {
     unittest.test("to-json--from-json", () {
       var o = buildCoverageBucket();
       var od = new api.CoverageBucket.fromJson(o.toJson());
       checkCoverageBucket(od);
     });
   });
 
 
   unittest.group("obj-schema-Dataset", () {
@@ skipping 16 matching lines @@
 
   unittest.group("obj-schema-ExperimentalCreateJobResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildExperimentalCreateJobResponse();
       var od = new api.ExperimentalCreateJobResponse.fromJson(o.toJson());
       checkExperimentalCreateJobResponse(od);
     });
   });
 
 
-  unittest.group("obj-schema-ExportReadsetsRequest", () {
+  unittest.group("obj-schema-ExportReadGroupSetsRequest", () {
     unittest.test("to-json--from-json", () {
-      var o = buildExportReadsetsRequest();
-      var od = new api.ExportReadsetsRequest.fromJson(o.toJson());
-      checkExportReadsetsRequest(od);
+      var o = buildExportReadGroupSetsRequest();
+      var od = new api.ExportReadGroupSetsRequest.fromJson(o.toJson());
+      checkExportReadGroupSetsRequest(od);
     });
   });
 
 
-  unittest.group("obj-schema-ExportReadsetsResponse", () {
+  unittest.group("obj-schema-ExportReadGroupSetsResponse", () {
     unittest.test("to-json--from-json", () {
-      var o = buildExportReadsetsResponse();
-      var od = new api.ExportReadsetsResponse.fromJson(o.toJson());
-      checkExportReadsetsResponse(od);
+      var o = buildExportReadGroupSetsResponse();
+      var od = new api.ExportReadGroupSetsResponse.fromJson(o.toJson());
+      checkExportReadGroupSetsResponse(od);
     });
   });
 
 
-  unittest.group("obj-schema-ExportVariantsRequest", () {
+  unittest.group("obj-schema-ExportVariantSetRequest", () {
     unittest.test("to-json--from-json", () {
-      var o = buildExportVariantsRequest();
-      var od = new api.ExportVariantsRequest.fromJson(o.toJson());
-      checkExportVariantsRequest(od);
+      var o = buildExportVariantSetRequest();
+      var od = new api.ExportVariantSetRequest.fromJson(o.toJson());
+      checkExportVariantSetRequest(od);
     });
   });
 
 
-  unittest.group("obj-schema-ExportVariantsResponse", () {
+  unittest.group("obj-schema-ExportVariantSetResponse", () {
     unittest.test("to-json--from-json", () {
-      var o = buildExportVariantsResponse();
-      var od = new api.ExportVariantsResponse.fromJson(o.toJson());
-      checkExportVariantsResponse(od);
+      var o = buildExportVariantSetResponse();
+      var od = new api.ExportVariantSetResponse.fromJson(o.toJson());
+      checkExportVariantSetResponse(od);
     });
   });
 
 
-  unittest.group("obj-schema-GenomicRange", () {
+  unittest.group("obj-schema-FastqMetadata", () {
     unittest.test("to-json--from-json", () {
-      var o = buildGenomicRange();
-      var od = new api.GenomicRange.fromJson(o.toJson());
-      checkGenomicRange(od);
+      var o = buildFastqMetadata();
+      var od = new api.FastqMetadata.fromJson(o.toJson());
+      checkFastqMetadata(od);
     });
   });
 
 
-  unittest.group("obj-schema-Header", () {
+  unittest.group("obj-schema-ImportReadGroupSetsRequest", () {
     unittest.test("to-json--from-json", () {
-      var o = buildHeader();
-      var od = new api.Header.fromJson(o.toJson());
-      checkHeader(od);
+      var o = buildImportReadGroupSetsRequest();
+      var od = new api.ImportReadGroupSetsRequest.fromJson(o.toJson());
+      checkImportReadGroupSetsRequest(od);
     });
   });
 
 
-  unittest.group("obj-schema-HeaderSection", () {
+  unittest.group("obj-schema-ImportReadGroupSetsResponse", () {
     unittest.test("to-json--from-json", () {
-      var o = buildHeaderSection();
-      var od = new api.HeaderSection.fromJson(o.toJson());
-      checkHeaderSection(od);
+      var o = buildImportReadGroupSetsResponse();
+      var od = new api.ImportReadGroupSetsResponse.fromJson(o.toJson());
+      checkImportReadGroupSetsResponse(od);
     });
   });
 
-
-  unittest.group("obj-schema-ImportReadsetsRequest", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildImportReadsetsRequest();
-      var od = new api.ImportReadsetsRequest.fromJson(o.toJson());
-      checkImportReadsetsRequest(od);
-    });
-  });
-
-
-  unittest.group("obj-schema-ImportReadsetsResponse", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildImportReadsetsResponse();
-      var od = new api.ImportReadsetsResponse.fromJson(o.toJson());
-      checkImportReadsetsResponse(od);
-    });
-  });
-
 
   unittest.group("obj-schema-ImportVariantsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildImportVariantsRequest();
       var od = new api.ImportVariantsRequest.fromJson(o.toJson());
       checkImportVariantsRequest(od);
     });
   });
 
 
   unittest.group("obj-schema-ImportVariantsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildImportVariantsResponse();
       var od = new api.ImportVariantsResponse.fromJson(o.toJson());
       checkImportVariantsResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-InterleavedFastqSource", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInterleavedFastqSource();
+      var od = new api.InterleavedFastqSource.fromJson(o.toJson());
+      checkInterleavedFastqSource(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Job", () {
     unittest.test("to-json--from-json", () {
       var o = buildJob();
       var od = new api.Job.fromJson(o.toJson());
       checkJob(od);
     });
   });
 
 
   unittest.group("obj-schema-JobRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildJobRequest();
       var od = new api.JobRequest.fromJson(o.toJson());
       checkJobRequest(od);
     });
   });
 
 
+  unittest.group("obj-schema-LinearAlignment", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildLinearAlignment();
+      var od = new api.LinearAlignment.fromJson(o.toJson());
+      checkLinearAlignment(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListBasesResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListBasesResponse();
+      var od = new api.ListBasesResponse.fromJson(o.toJson());
+      checkListBasesResponse(od);
+    });
+  });
+
+
   unittest.group("obj-schema-ListCoverageBucketsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListCoverageBucketsResponse();
       var od = new api.ListCoverageBucketsResponse.fromJson(o.toJson());
       checkListCoverageBucketsResponse(od);
     });
   });
 
 
   unittest.group("obj-schema-ListDatasetsResponse", () {
@@ skipping 16 matching lines @@
 
   unittest.group("obj-schema-Metadata", () {
     unittest.test("to-json--from-json", () {
       var o = buildMetadata();
       var od = new api.Metadata.fromJson(o.toJson());
       checkMetadata(od);
     });
   });
 
 
-  unittest.group("obj-schema-Program", () {
+  unittest.group("obj-schema-PairedFastqSource", () {
     unittest.test("to-json--from-json", () {
-      var o = buildProgram();
-      var od = new api.Program.fromJson(o.toJson());
-      checkProgram(od);
+      var o = buildPairedFastqSource();
+      var od = new api.PairedFastqSource.fromJson(o.toJson());
+      checkPairedFastqSource(od);
     });
   });
 
+
+  unittest.group("obj-schema-Position", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildPosition();
+      var od = new api.Position.fromJson(o.toJson());
+      checkPosition(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Range", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRange();
+      var od = new api.Range.fromJson(o.toJson());
+      checkRange(od);
+    });
+  });
+
 
   unittest.group("obj-schema-Read", () {
     unittest.test("to-json--from-json", () {
       var o = buildRead();
       var od = new api.Read.fromJson(o.toJson());
       checkRead(od);
     });
   });
 
 
   unittest.group("obj-schema-ReadGroup", () {
     unittest.test("to-json--from-json", () {
       var o = buildReadGroup();
       var od = new api.ReadGroup.fromJson(o.toJson());
       checkReadGroup(od);
     });
   });
 
 
-  unittest.group("obj-schema-Readset", () {
+  unittest.group("obj-schema-ReadGroupExperiment", () {
     unittest.test("to-json--from-json", () {
-      var o = buildReadset();
-      var od = new api.Readset.fromJson(o.toJson());
-      checkReadset(od);
+      var o = buildReadGroupExperiment();
+      var od = new api.ReadGroupExperiment.fromJson(o.toJson());
+      checkReadGroupExperiment(od);
     });
   });
 
+
+  unittest.group("obj-schema-ReadGroupProgram", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildReadGroupProgram();
+      var od = new api.ReadGroupProgram.fromJson(o.toJson());
+      checkReadGroupProgram(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ReadGroupSet", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildReadGroupSet();
+      var od = new api.ReadGroupSet.fromJson(o.toJson());
+      checkReadGroupSet(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Reference", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildReference();
+      var od = new api.Reference.fromJson(o.toJson());
+      checkReference(od);
+    });
+  });
+
 
   unittest.group("obj-schema-ReferenceBound", () {
     unittest.test("to-json--from-json", () {
       var o = buildReferenceBound();
       var od = new api.ReferenceBound.fromJson(o.toJson());
       checkReferenceBound(od);
     });
   });
 
 
-  unittest.group("obj-schema-ReferenceSequence", () {
+  unittest.group("obj-schema-ReferenceSet", () {
     unittest.test("to-json--from-json", () {
-      var o = buildReferenceSequence();
-      var od = new api.ReferenceSequence.fromJson(o.toJson());
-      checkReferenceSequence(od);
+      var o = buildReferenceSet();
+      var od = new api.ReferenceSet.fromJson(o.toJson());
+      checkReferenceSet(od);
     });
   });
 
 
   unittest.group("obj-schema-SearchCallSetsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchCallSetsRequest();
       var od = new api.SearchCallSetsRequest.fromJson(o.toJson());
       checkSearchCallSetsRequest(od);
     });
@@ skipping 20 matching lines @@
 
   unittest.group("obj-schema-SearchJobsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchJobsResponse();
       var od = new api.SearchJobsResponse.fromJson(o.toJson());
       checkSearchJobsResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-SearchReadGroupSetsRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSearchReadGroupSetsRequest();
+      var od = new api.SearchReadGroupSetsRequest.fromJson(o.toJson());
+      checkSearchReadGroupSetsRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-SearchReadGroupSetsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSearchReadGroupSetsResponse();
+      var od = new api.SearchReadGroupSetsResponse.fromJson(o.toJson());
+      checkSearchReadGroupSetsResponse(od);
+    });
+  });
+
+
   unittest.group("obj-schema-SearchReadsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchReadsRequest();
       var od = new api.SearchReadsRequest.fromJson(o.toJson());
       checkSearchReadsRequest(od);
     });
   });
 
 
   unittest.group("obj-schema-SearchReadsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchReadsResponse();
       var od = new api.SearchReadsResponse.fromJson(o.toJson());
       checkSearchReadsResponse(od);
     });
   });
 
 
-  unittest.group("obj-schema-SearchReadsetsRequest", () {
+  unittest.group("obj-schema-SearchReferenceSetsRequest", () {
     unittest.test("to-json--from-json", () {
-      var o = buildSearchReadsetsRequest();
-      var od = new api.SearchReadsetsRequest.fromJson(o.toJson());
-      checkSearchReadsetsRequest(od);
+      var o = buildSearchReferenceSetsRequest();
+      var od = new api.SearchReferenceSetsRequest.fromJson(o.toJson());
+      checkSearchReferenceSetsRequest(od);
     });
   });
 
 
-  unittest.group("obj-schema-SearchReadsetsResponse", () {
+  unittest.group("obj-schema-SearchReferenceSetsResponse", () {
     unittest.test("to-json--from-json", () {
-      var o = buildSearchReadsetsResponse();
-      var od = new api.SearchReadsetsResponse.fromJson(o.toJson());
-      checkSearchReadsetsResponse(od);
+      var o = buildSearchReferenceSetsResponse();
+      var od = new api.SearchReferenceSetsResponse.fromJson(o.toJson());
+      checkSearchReferenceSetsResponse(od);
     });
   });
 
+
+  unittest.group("obj-schema-SearchReferencesRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSearchReferencesRequest();
+      var od = new api.SearchReferencesRequest.fromJson(o.toJson());
+      checkSearchReferencesRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-SearchReferencesResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSearchReferencesResponse();
+      var od = new api.SearchReferencesResponse.fromJson(o.toJson());
+      checkSearchReferencesResponse(od);
+    });
+  });
+
 
   unittest.group("obj-schema-SearchVariantSetsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchVariantSetsRequest();
       var od = new api.SearchVariantSetsRequest.fromJson(o.toJson());
       checkSearchVariantSetsRequest(od);
     });
   });
 
 
@@ skipping 35 matching lines @@
 
   unittest.group("obj-schema-VariantSet", () {
     unittest.test("to-json--from-json", () {
       var o = buildVariantSet();
       var od = new api.VariantSet.fromJson(o.toJson());
       checkVariantSet(od);
     });
   });
 
 
-  unittest.group("resource-BeaconsResourceApi", () {
-    unittest.test("method--get", () {
-
-      var mock = new common_test.HttpServerMock();
-      api.BeaconsResourceApi res = new api.GenomicsApi(mock).beacons;
-      var arg_variantSetId = "foo";
-      var arg_allele = "foo";
-      var arg_position = "foo";
-      var arg_referenceName = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("beacons/"));
-        pathOffset += 8;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
-
-        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(queryMap["allele"].first, unittest.equals(arg_allele));
-        unittest.expect(queryMap["position"].first, unittest.equals(arg_position));
-        unittest.expect(queryMap["referenceName"].first, unittest.equals(arg_referenceName));
-
-
-        var h = {
-          "content-type" : "application/json; charset=utf-8",
-        };
-        var resp = convert.JSON.encode(buildBeacon());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
-      }), true);
-      res.get(arg_variantSetId, allele: arg_allele, position: arg_position, referenceName: arg_referenceName).then(unittest.expectAsync(((api.Beacon response) {
-        checkBeacon(response);
-      })));
-    });
-
-  });
-
-
   unittest.group("resource-CallsetsResourceApi", () {
     unittest.test("method--create", () {
 
       var mock = new common_test.HttpServerMock();
       api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;
       var arg_request = buildCallSet();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.CallSet.fromJson(json);
         checkCallSet(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("callsets"));
         pathOffset += 8;
 
         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;
@@ skipping 24 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;
       var arg_callSetId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("callsets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_callSetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 25 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;
       var arg_callSetId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("callsets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_callSetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 31 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.CallSet.fromJson(json);
         checkCallSet(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("callsets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_callSetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 30 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.SearchCallSetsRequest.fromJson(json);
         checkSearchCallSetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("callsets/search"));
         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;
@@ skipping 28 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.CallSet.fromJson(json);
         checkCallSet(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("callsets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_callSetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 34 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Dataset.fromJson(json);
         checkDataset(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("datasets"));
         pathOffset += 8;
 
         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;
@@ skipping 24 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_datasetId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("datasets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_datasetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 25 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_datasetId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("datasets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_datasetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 19 matching lines @@
       }), true);
       res.get(arg_datasetId).then(unittest.expectAsync(((api.Dataset response) {
         checkDataset(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new common_test.HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
-      var arg_maxResults = "foo";
+      var arg_pageSize = 42;
       var arg_pageToken = "foo";
-      var arg_projectId = "foo";
+      var arg_projectNumber = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("datasets"));
         pathOffset += 8;
 
         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(queryMap["maxResults"].first, unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["projectId"].first, unittest.equals(arg_projectId));
+        unittest.expect(queryMap["projectNumber"].first, unittest.equals(arg_projectNumber));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListDatasetsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.list(maxResults: arg_maxResults, pageToken: arg_pageToken, projectId: arg_projectId).then(unittest.expectAsync(((api.ListDatasetsResponse response) {
+      res.list(pageSize: arg_pageSize, pageToken: arg_pageToken, projectNumber: arg_projectNumber).then(unittest.expectAsync(((api.ListDatasetsResponse response) {
         checkListDatasetsResponse(response);
       })));
     });
 
     unittest.test("method--patch", () {
 
       var mock = new common_test.HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_request = buildDataset();
       var arg_datasetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Dataset.fromJson(json);
         checkDataset(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("datasets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_datasetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 27 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_datasetId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("datasets/"));
         pathOffset += 9;
         index = path.indexOf("/undelete", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_datasetId"));
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/undelete"));
         pathOffset += 9;
 
@@ skipping 35 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Dataset.fromJson(json);
         checkDataset(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("datasets/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_datasetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 34 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.ExperimentalCreateJobRequest.fromJson(json);
         checkExperimentalCreateJobRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("experimental/jobs/create"));
         pathOffset += 24;
 
         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;
@@ skipping 28 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.JobsResourceApi res = new api.GenomicsApi(mock).jobs;
       var arg_jobId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equals("jobs/"));
         pathOffset += 5;
         index = path.indexOf("/cancel", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_jobId"));
         unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/cancel"));
         pathOffset += 7;
 
@@ skipping 29 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.JobsResourceApi res = new api.GenomicsApi(mock).jobs;
       var arg_jobId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equals("jobs/"));
         pathOffset += 5;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_jobId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 30 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.SearchJobsRequest.fromJson(json);
         checkSearchJobsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("jobs/search"));
         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;
@@ skipping 15 matching lines @@
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
       res.search(arg_request).then(unittest.expectAsync(((api.SearchJobsResponse response) {
         checkSearchJobsResponse(response);
       })));
     });
 
   });
 
 
-  unittest.group("resource-ReadsResourceApi", () {
+  unittest.group("resource-ReadgroupsetsResourceApi", () {
+    unittest.test("method--align", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildAlignReadGroupSetsRequest();
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.AlignReadGroupSetsRequest.fromJson(json);
+        checkAlignReadGroupSetsRequest(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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("readgroupsets/align"));
+        pathOffset += 19;
+
+        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(buildAlignReadGroupSetsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.align(arg_request).then(unittest.expectAsync(((api.AlignReadGroupSetsResponse response) {
+        checkAlignReadGroupSetsResponse(response);
+      })));
+    });
+
+    unittest.test("method--call", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildCallReadGroupSetsRequest();
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.CallReadGroupSetsRequest.fromJson(json);
+        checkCallReadGroupSetsRequest(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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("readgroupsets/call"));
+        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(buildCallReadGroupSetsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.call(arg_request).then(unittest.expectAsync(((api.CallReadGroupSetsResponse response) {
+        checkCallReadGroupSetsResponse(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_readGroupSetId = "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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("readgroupsets/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_readGroupSetId"));
+
+        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 = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_readGroupSetId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--export", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildExportReadGroupSetsRequest();
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ExportReadGroupSetsRequest.fromJson(json);
+        checkExportReadGroupSetsRequest(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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("readgroupsets/export"));
+        pathOffset += 20;
+
+        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(buildExportReadGroupSetsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.export(arg_request).then(unittest.expectAsync(((api.ExportReadGroupSetsResponse response) {
+        checkExportReadGroupSetsResponse(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_readGroupSetId = "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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("readgroupsets/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_readGroupSetId"));
+
+        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(buildReadGroupSet());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_readGroupSetId).then(unittest.expectAsync(((api.ReadGroupSet response) {
+        checkReadGroupSet(response);
+      })));
+    });
+
+    unittest.test("method--import", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildImportReadGroupSetsRequest();
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ImportReadGroupSetsRequest.fromJson(json);
+        checkImportReadGroupSetsRequest(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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("readgroupsets/import"));
+        pathOffset += 20;
+
+        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(buildImportReadGroupSetsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.import(arg_request).then(unittest.expectAsync(((api.ImportReadGroupSetsResponse response) {
+        checkImportReadGroupSetsResponse(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildReadGroupSet();
+      var arg_readGroupSetId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ReadGroupSet.fromJson(json);
+        checkReadGroupSet(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 + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("readgroupsets/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_readGroupSetId"));
+
+        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(buildReadGroupSet());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_readGroupSetId).then(unittest.expectAsync(((api.ReadGroupSet response) {
+        checkReadGroupSet(response);
+      })));
+    });
+
     unittest.test("method--search", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsResourceApi res = new api.GenomicsApi(mock).reads;
-      var arg_request = buildSearchReadsRequest();
-      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.SearchReadsRequest.fromJson(json);
-        checkSearchReadsRequest(obj);
-
-        var path = (req.url).path;
-        var pathOffset = 0;
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildSearchReadGroupSetsRequest();
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.SearchReadGroupSetsRequest.fromJson(json);
+        checkSearchReadGroupSetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("reads/search"));
-        pathOffset += 12;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("readgroupsets/search"));
+        pathOffset += 20;
 
         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(buildSearchReadsResponse());
+        var resp = convert.JSON.encode(buildSearchReadGroupSetsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsResponse response) {
-        checkSearchReadsResponse(response);
+      res.search(arg_request).then(unittest.expectAsync(((api.SearchReadGroupSetsResponse response) {
+        checkSearchReadGroupSetsResponse(response);
       })));
     });
 
-  });
-
-
-  unittest.group("resource-ReadsetsResourceApi", () {
-    unittest.test("method--delete", () {
+    unittest.test("method--update", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_readsetId = "foo";
+      api.ReadgroupsetsResourceApi res = new api.GenomicsApi(mock).readgroupsets;
+      var arg_request = buildReadGroupSet();
+      var arg_readGroupSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ReadGroupSet.fromJson(json);
+        checkReadGroupSet(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("readsets/"));
-        pathOffset += 9;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("readgroupsets/"));
+        pathOffset += 14;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_readsetId"));
+        unittest.expect(subPart, unittest.equals("$arg_readGroupSetId"));
 
         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 = "";
+        var resp = convert.JSON.encode(buildReadGroupSet());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_readsetId).then(unittest.expectAsync((_) {}));
+      res.update(arg_request, arg_readGroupSetId).then(unittest.expectAsync(((api.ReadGroupSet response) {
+        checkReadGroupSet(response);
+      })));
     });
 
-    unittest.test("method--export", () {
+  });
+
+
+  unittest.group("resource-ReadgroupsetsCoveragebucketsResourceApi", () {
+    unittest.test("method--list", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_request = buildExportReadsetsRequest();
+      api.ReadgroupsetsCoveragebucketsResourceApi res = new api.GenomicsApi(mock).readgroupsets.coveragebuckets;
+      var arg_readGroupSetId = "foo";
+      var arg_pageSize = 42;
+      var arg_pageToken = "foo";
+      var arg_range_end = "foo";
+      var arg_range_referenceName = "foo";
+      var arg_range_start = "foo";
+      var arg_targetBucketWidth = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.ExportReadsetsRequest.fromJson(json);
-        checkExportReadsetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("readgroupsets/"));
+        pathOffset += 14;
+        index = path.indexOf("/coveragebuckets", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_readGroupSetId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/coveragebuckets"));
         pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("readsets/export"));
-        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]));
           }
         }
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(queryMap["range.end"].first, unittest.equals(arg_range_end));
+        unittest.expect(queryMap["range.referenceName"].first, unittest.equals(arg_range_referenceName));
+        unittest.expect(queryMap["range.start"].first, unittest.equals(arg_range_start));
+        unittest.expect(queryMap["targetBucketWidth"].first, unittest.equals(arg_targetBucketWidth));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
-        var resp = convert.JSON.encode(buildExportReadsetsResponse());
+        var resp = convert.JSON.encode(buildListCoverageBucketsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.export(arg_request).then(unittest.expectAsync(((api.ExportReadsetsResponse response) {
-        checkExportReadsetsResponse(response);
+      res.list(arg_readGroupSetId, pageSize: arg_pageSize, pageToken: arg_pageToken, range_end: arg_range_end, range_referenceName: arg_range_referenceName, range_start: arg_range_start, targetBucketWidth: arg_targetBucketWidth).then(unittest.expectAsync(((api.ListCoverageBucketsResponse response) {
+        checkListCoverageBucketsResponse(response);
       })));
     });
 
-    unittest.test("method--get", () {
+  });
+
+
+  unittest.group("resource-ReadsResourceApi", () {
+    unittest.test("method--search", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_readsetId = "foo";
+      api.ReadsResourceApi res = new api.GenomicsApi(mock).reads;
+      var arg_request = buildSearchReadsRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.SearchReadsRequest.fromJson(json);
+        checkSearchReadsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("readsets/"));
-        pathOffset += 9;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_readsetId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("reads/search"));
+        pathOffset += 12;
 
         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(buildReadset());
+        var resp = convert.JSON.encode(buildSearchReadsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.get(arg_readsetId).then(unittest.expectAsync(((api.Readset response) {
-        checkReadset(response);
+      res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsResponse response) {
+        checkSearchReadsResponse(response);
       })));
     });
 
-    unittest.test("method--import", () {
+  });
+
+
+  unittest.group("resource-ReferencesResourceApi", () {
+    unittest.test("method--get", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_request = buildImportReadsetsRequest();
+      api.ReferencesResourceApi res = new api.GenomicsApi(mock).references;
+      var arg_referenceId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.ImportReadsetsRequest.fromJson(json);
-        checkImportReadsetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("readsets/import"));
-        pathOffset += 15;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("references/"));
+        pathOffset += 11;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_referenceId"));
 
         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(buildImportReadsetsResponse());
+        var resp = convert.JSON.encode(buildReference());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.import(arg_request).then(unittest.expectAsync(((api.ImportReadsetsResponse response) {
-        checkImportReadsetsResponse(response);
+      res.get(arg_referenceId).then(unittest.expectAsync(((api.Reference response) {
+        checkReference(response);
       })));
     });
 
-    unittest.test("method--patch", () {
+    unittest.test("method--search", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_request = buildReadset();
-      var arg_readsetId = "foo";
+      api.ReferencesResourceApi res = new api.GenomicsApi(mock).references;
+      var arg_request = buildSearchReferencesRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.Readset.fromJson(json);
-        checkReadset(obj);
+        var obj = new api.SearchReferencesRequest.fromJson(json);
+        checkSearchReferencesRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("readsets/"));
-        pathOffset += 9;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_readsetId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("references/search"));
+        pathOffset += 17;
 
         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(buildReadset());
+        var resp = convert.JSON.encode(buildSearchReferencesResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.patch(arg_request, arg_readsetId).then(unittest.expectAsync(((api.Readset response) {
-        checkReadset(response);
+      res.search(arg_request).then(unittest.expectAsync(((api.SearchReferencesResponse response) {
+        checkSearchReferencesResponse(response);
       })));
     });
 
-    unittest.test("method--search", () {
+  });
+
+
+  unittest.group("resource-ReferencesBasesResourceApi", () {
+    unittest.test("method--list", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_request = buildSearchReadsetsRequest();
+      api.ReferencesBasesResourceApi res = new api.GenomicsApi(mock).references.bases;
+      var arg_referenceId = "foo";
+      var arg_end = "foo";
+      var arg_pageSize = 42;
+      var arg_pageToken = "foo";
+      var arg_start = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.SearchReadsetsRequest.fromJson(json);
-        checkSearchReadsetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("readsets/search"));
-        pathOffset += 15;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("references/"));
+        pathOffset += 11;
+        index = path.indexOf("/bases", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_referenceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/bases"));
+        pathOffset += 6;
 
         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(queryMap["end"].first, unittest.equals(arg_end));
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(queryMap["start"].first, unittest.equals(arg_start));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
-        var resp = convert.JSON.encode(buildSearchReadsetsResponse());
+        var resp = convert.JSON.encode(buildListBasesResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsetsResponse response) {
-        checkSearchReadsetsResponse(response);
+      res.list(arg_referenceId, end: arg_end, pageSize: arg_pageSize, pageToken: arg_pageToken, start: arg_start).then(unittest.expectAsync(((api.ListBasesResponse response) {
+        checkListBasesResponse(response);
       })));
     });
 
-    unittest.test("method--update", () {
+  });
+
+
+  unittest.group("resource-ReferencesetsResourceApi", () {
+    unittest.test("method--get", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;
-      var arg_request = buildReadset();
-      var arg_readsetId = "foo";
+      api.ReferencesetsResourceApi res = new api.GenomicsApi(mock).referencesets;
+      var arg_referenceSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.Readset.fromJson(json);
-        checkReadset(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("readsets/"));
-        pathOffset += 9;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("referencesets/"));
+        pathOffset += 14;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_readsetId"));
+        unittest.expect(subPart, unittest.equals("$arg_referenceSetId"));
 
         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(buildReadset());
+        var resp = convert.JSON.encode(buildReferenceSet());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_readsetId).then(unittest.expectAsync(((api.Readset response) {
-        checkReadset(response);
+      res.get(arg_referenceSetId).then(unittest.expectAsync(((api.ReferenceSet response) {
+        checkReferenceSet(response);
       })));
     });
 
-  });
-
-
-  unittest.group("resource-ReadsetsCoveragebucketsResourceApi", () {
-    unittest.test("method--list", () {
+    unittest.test("method--search", () {
 
       var mock = new common_test.HttpServerMock();
-      api.ReadsetsCoveragebucketsResourceApi res = new api.GenomicsApi(mock).readsets.coveragebuckets;
-      var arg_readsetId = "foo";
-      var arg_maxResults = "foo";
-      var arg_pageToken = "foo";
-      var arg_range_sequenceEnd = "foo";
-      var arg_range_sequenceName = "foo";
-      var arg_range_sequenceStart = "foo";
-      var arg_targetBucketWidth = "foo";
+      api.ReferencesetsResourceApi res = new api.GenomicsApi(mock).referencesets;
+      var arg_request = buildSearchReferenceSetsRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.SearchReferenceSetsRequest.fromJson(json);
+        checkSearchReferenceSetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("readsets/"));
-        pathOffset += 9;
-        index = path.indexOf("/coveragebuckets", pathOffset);
-        unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
-        pathOffset = index;
-        unittest.expect(subPart, unittest.equals("$arg_readsetId"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/coveragebuckets"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("referencesets/search"));
+        pathOffset += 20;
 
         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(queryMap["maxResults"].first, unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["range.sequenceEnd"].first, unittest.equals(arg_range_sequenceEnd));
-        unittest.expect(queryMap["range.sequenceName"].first, unittest.equals(arg_range_sequenceName));
-        unittest.expect(queryMap["range.sequenceStart"].first, unittest.equals(arg_range_sequenceStart));
-        unittest.expect(queryMap["targetBucketWidth"].first, unittest.equals(arg_targetBucketWidth));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
-        var resp = convert.JSON.encode(buildListCoverageBucketsResponse());
+        var resp = convert.JSON.encode(buildSearchReferenceSetsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.list(arg_readsetId, maxResults: arg_maxResults, pageToken: arg_pageToken, range_sequenceEnd: arg_range_sequenceEnd, range_sequenceName: arg_range_sequenceName, range_sequenceStart: arg_range_sequenceStart, targetBucketWidth: arg_targetBucketWidth).then(unittest.expectAsync(((api.ListCoverageBucketsResponse response) {
-        checkListCoverageBucketsResponse(response);
+      res.search(arg_request).then(unittest.expectAsync(((api.SearchReferenceSetsResponse response) {
+        checkSearchReferenceSetsResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-VariantsResourceApi", () {
     unittest.test("method--create", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
       var arg_request = buildVariant();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Variant.fromJson(json);
         checkVariant(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("variants"));
         pathOffset += 8;
 
         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;
@@ skipping 24 matching lines @@
       var mock = new common_test.HttpServerMock();
       api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
       var arg_variantId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("variants/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_variantId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 13 matching lines @@
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
       res.delete(arg_variantId).then(unittest.expectAsync((_) {}));
     });
 
-    unittest.test("method--export", () {
+    unittest.test("method--get", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
-      var arg_request = buildExportVariantsRequest();
+      var arg_variantId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.ExportVariantsRequest.fromJson(json);
-        checkExportVariantsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("variants/export"));
-        pathOffset += 15;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("variants/"));
+        pathOffset += 9;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_variantId"));
 
         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(buildExportVariantsResponse());
+        var resp = convert.JSON.encode(buildVariant());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.export(arg_request).then(unittest.expectAsync(((api.ExportVariantsResponse response) {
-        checkExportVariantsResponse(response);
+      res.get(arg_variantId).then(unittest.expectAsync(((api.Variant response) {
+        checkVariant(response);
       })));
     });
 
-    unittest.test("method--get", () {
+    unittest.test("method--search", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
-      var arg_variantId = "foo";
+      var arg_request = buildSearchVariantsRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.SearchVariantsRequest.fromJson(json);
+        checkSearchVariantsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("variants/"));
-        pathOffset += 9;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_variantId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("variants/search"));
+        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(buildVariant());
+        var resp = convert.JSON.encode(buildSearchVariantsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.get(arg_variantId).then(unittest.expectAsync(((api.Variant response) {
-        checkVariant(response);
+      res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantsResponse response) {
+        checkSearchVariantsResponse(response);
       })));
     });
 
-    unittest.test("method--import", () {
+    unittest.test("method--update", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
-      var arg_request = buildImportVariantsRequest();
+      var arg_request = buildVariant();
+      var arg_variantId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.ImportVariantsRequest.fromJson(json);
-        checkImportVariantsRequest(obj);
+        var obj = new api.Variant.fromJson(json);
+        checkVariant(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("variants/import"));
-        pathOffset += 15;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("variants/"));
+        pathOffset += 9;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_variantId"));
 
         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(buildImportVariantsResponse());
+        var resp = convert.JSON.encode(buildVariant());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.import(arg_request).then(unittest.expectAsync(((api.ImportVariantsResponse response) {
-        checkImportVariantsResponse(response);
+      res.update(arg_request, arg_variantId).then(unittest.expectAsync(((api.Variant response) {
+        checkVariant(response);
       })));
     });
 
-    unittest.test("method--search", () {
+  });
+
+
+  unittest.group("resource-VariantsetsResourceApi", () {
+    unittest.test("method--delete", () {
 
       var mock = new common_test.HttpServerMock();
-      api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
-      var arg_request = buildSearchVariantsRequest();
+      api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;
+      var arg_variantSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.SearchVariantsRequest.fromJson(json);
-        checkSearchVariantsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("variants/search"));
-        pathOffset += 15;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
 
         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(buildSearchVariantsResponse());
+        var resp = "";
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantsResponse response) {
-        checkSearchVariantsResponse(response);
-      })));
+      res.delete(arg_variantSetId).then(unittest.expectAsync((_) {}));
     });
 
-    unittest.test("method--update", () {
+    unittest.test("method--export", () {
 
       var mock = new common_test.HttpServerMock();
-      api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;
-      var arg_request = buildVariant();
-      var arg_variantId = "foo";
+      api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;
+      var arg_request = buildExportVariantSetRequest();
+      var arg_variantSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.Variant.fromJson(json);
-        checkVariant(obj);
+        var obj = new api.ExportVariantSetRequest.fromJson(json);
+        checkExportVariantSetRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("variants/"));
-        pathOffset += 9;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_variantId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
+        pathOffset += 12;
+        index = path.indexOf("/export", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/export"));
+        pathOffset += 7;
 
         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(buildVariant());
+        var resp = convert.JSON.encode(buildExportVariantSetResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_variantId).then(unittest.expectAsync(((api.Variant response) {
-        checkVariant(response);
+      res.export(arg_request, arg_variantSetId).then(unittest.expectAsync(((api.ExportVariantSetResponse response) {
+        checkExportVariantSetResponse(response);
       })));
     });
 
-  });
-
-
-  unittest.group("resource-VariantsetsResourceApi", () {
-    unittest.test("method--delete", () {
+    unittest.test("method--get", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;
       var arg_variantSetId = "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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
         pathOffset += 12;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
 
         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 = "";
+        var resp = convert.JSON.encode(buildVariantSet());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_variantSetId).then(unittest.expectAsync((_) {}));
+      res.get(arg_variantSetId).then(unittest.expectAsync(((api.VariantSet response) {
+        checkVariantSet(response);
+      })));
     });
 
-    unittest.test("method--get", () {
+    unittest.test("method--importVariants", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;
+      var arg_request = buildImportVariantsRequest();
       var arg_variantSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ImportVariantsRequest.fromJson(json);
+        checkImportVariantsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
         pathOffset += 12;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
+        index = path.indexOf("/importVariants", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/importVariants"));
+        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(buildVariantSet());
+        var resp = convert.JSON.encode(buildImportVariantsResponse());
         return new async.Future.value(common_test.stringResponse(200, h, resp));
       }), true);
-      res.get(arg_variantSetId).then(unittest.expectAsync(((api.VariantSet response) {
-        checkVariantSet(response);
+      res.importVariants(arg_request, arg_variantSetId).then(unittest.expectAsync(((api.ImportVariantsResponse response) {
+        checkImportVariantsResponse(response);
       })));
     });
 
     unittest.test("method--mergeVariants", () {
 
       var mock = new common_test.HttpServerMock();
       api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;
       var arg_request = buildMergeVariantsRequest();
       var arg_variantSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.MergeVariantsRequest.fromJson(json);
         checkMergeVariantsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
         pathOffset += 12;
         index = path.indexOf("/mergeVariants", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
         unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/mergeVariants"));
         pathOffset += 14;
 
@@ skipping 33 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.VariantSet.fromJson(json);
         checkVariantSet(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
         pathOffset += 12;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 30 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.SearchVariantSetsRequest.fromJson(json);
         checkSearchVariantSetsRequest(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("variantsets/search"));
         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;
@@ skipping 28 matching lines @@
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.VariantSet.fromJson(json);
         checkVariantSet(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 + 16), unittest.equals("genomics/v1beta/"));
-        pathOffset += 16;
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("genomics/v1beta2/"));
+        pathOffset += 17;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("variantsets/"));
         pathOffset += 12;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_variantSetId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
@@ skipping 20 matching lines @@
       res.update(arg_request, arg_variantSetId).then(unittest.expectAsync(((api.VariantSet response) {
         checkVariantSet(response);
       })));
     });
 
   });
 
 
 }