Api-roll 22: 2015-08-17

generated/googleapis/test/genomics/v1_test.dart

 library googleapis.genomics.v1.test;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart' as http_testing;
 import 'package:unittest/unittest.dart' as unittest;
@@ skipping 33 matching lines @@
     }
   }
 }
 
 http.StreamedResponse stringResponse(
     core.int status, core.Map headers, core.String body) {
   var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
   return new http.StreamedResponse(stream, status, headers: headers);
 }
 
-buildUnnamed1774() {
+buildUnnamed1866() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1866(core.List<core.String> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  unittest.expect(o[0], unittest.equals('foo'));
+  unittest.expect(o[1], unittest.equals('foo'));
+}
+
+core.int buildCounterBinding = 0;
+buildBinding() {
+  var o = new api.Binding();
+  buildCounterBinding++;
+  if (buildCounterBinding < 3) {
+    o.members = buildUnnamed1866();
+    o.role = "foo";
+  }
+  buildCounterBinding--;
+  return o;
+}
+
+checkBinding(api.Binding o) {
+  buildCounterBinding++;
+  if (buildCounterBinding < 3) {
+    checkUnnamed1866(o.members);
+    unittest.expect(o.role, unittest.equals('foo'));
+  }
+  buildCounterBinding--;
+}
+
+buildUnnamed1867() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1774(core.List<core.Object> o) {
+checkUnnamed1867(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted1 = (o[0]) as core.Map; unittest.expect(casted1, unittest.hasLength(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], unittest.equals('foo')); 
   var casted2 = (o[1]) as core.Map; unittest.expect(casted2, unittest.hasLength(3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.expect(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1775() {
+buildUnnamed1868() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1774();
-  o["y"] = buildUnnamed1774();
+  o["x"] = buildUnnamed1867();
+  o["y"] = buildUnnamed1867();
   return o;
 }
 
-checkUnnamed1775(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1868(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1774(o["x"]);
-  checkUnnamed1774(o["y"]);
+  checkUnnamed1867(o["x"]);
+  checkUnnamed1867(o["y"]);
 }
 
-buildUnnamed1776() {
+buildUnnamed1869() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1776(core.List<core.String> o) {
+checkUnnamed1869(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 = buildUnnamed1775();
+    o.info = buildUnnamed1868();
     o.name = "foo";
     o.sampleId = "foo";
-    o.variantSetIds = buildUnnamed1776();
+    o.variantSetIds = buildUnnamed1869();
   }
   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'));
-    checkUnnamed1775(o.info);
+    checkUnnamed1868(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.sampleId, unittest.equals('foo'));
-    checkUnnamed1776(o.variantSetIds);
+    checkUnnamed1869(o.variantSetIds);
   }
   buildCounterCallSet--;
 }
 
 core.int buildCounterCancelOperationRequest = 0;
 buildCancelOperationRequest() {
   var o = new api.CancelOperationRequest();
   buildCounterCancelOperationRequest++;
   if (buildCounterCancelOperationRequest < 3) {
   }
@@ skipping 24 matching lines @@
 checkCigarUnit(api.CigarUnit o) {
   buildCounterCigarUnit++;
   if (buildCounterCigarUnit < 3) {
     unittest.expect(o.operation, unittest.equals('foo'));
     unittest.expect(o.operationLength, unittest.equals('foo'));
     unittest.expect(o.referenceSequence, unittest.equals('foo'));
   }
   buildCounterCigarUnit--;
 }
 
+core.int buildCounterCloudAuditOptions = 0;
+buildCloudAuditOptions() {
+  var o = new api.CloudAuditOptions();
+  buildCounterCloudAuditOptions++;
+  if (buildCounterCloudAuditOptions < 3) {
+  }
+  buildCounterCloudAuditOptions--;
+  return o;
+}
+
+checkCloudAuditOptions(api.CloudAuditOptions o) {
+  buildCounterCloudAuditOptions++;
+  if (buildCounterCloudAuditOptions < 3) {
+  }
+  buildCounterCloudAuditOptions--;
+}
+
+buildUnnamed1870() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1870(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 buildCounterCondition = 0;
+buildCondition() {
+  var o = new api.Condition();
+  buildCounterCondition++;
+  if (buildCounterCondition < 3) {
+    o.iam = "foo";
+    o.op = "foo";
+    o.svc = "foo";
+    o.sys = "foo";
+    o.value = "foo";
+    o.values = buildUnnamed1870();
+  }
+  buildCounterCondition--;
+  return o;
+}
+
+checkCondition(api.Condition o) {
+  buildCounterCondition++;
+  if (buildCounterCondition < 3) {
+    unittest.expect(o.iam, unittest.equals('foo'));
+    unittest.expect(o.op, unittest.equals('foo'));
+    unittest.expect(o.svc, unittest.equals('foo'));
+    unittest.expect(o.sys, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+    checkUnnamed1870(o.values);
+  }
+  buildCounterCondition--;
+}
+
+core.int buildCounterCounterOptions = 0;
+buildCounterOptions() {
+  var o = new api.CounterOptions();
+  buildCounterCounterOptions++;
+  if (buildCounterCounterOptions < 3) {
+    o.field = "foo";
+    o.metric = "foo";
+  }
+  buildCounterCounterOptions--;
+  return o;
+}
+
+checkCounterOptions(api.CounterOptions o) {
+  buildCounterCounterOptions++;
+  if (buildCounterCounterOptions < 3) {
+    unittest.expect(o.field, unittest.equals('foo'));
+    unittest.expect(o.metric, unittest.equals('foo'));
+  }
+  buildCounterCounterOptions--;
+}
+
 core.int buildCounterCoverageBucket = 0;
 buildCoverageBucket() {
   var o = new api.CoverageBucket();
   buildCounterCoverageBucket++;
   if (buildCounterCoverageBucket < 3) {
     o.meanCoverage = 42.0;
     o.range = buildRange();
   }
   buildCounterCoverageBucket--;
   return o;
 }
 
 checkCoverageBucket(api.CoverageBucket o) {
   buildCounterCoverageBucket++;
   if (buildCounterCoverageBucket < 3) {
     unittest.expect(o.meanCoverage, unittest.equals(42.0));
     checkRange(o.range);
   }
   buildCounterCoverageBucket--;
 }
 
+core.int buildCounterDataAccessOptions = 0;
+buildDataAccessOptions() {
+  var o = new api.DataAccessOptions();
+  buildCounterDataAccessOptions++;
+  if (buildCounterDataAccessOptions < 3) {
+  }
+  buildCounterDataAccessOptions--;
+  return o;
+}
+
+checkDataAccessOptions(api.DataAccessOptions o) {
+  buildCounterDataAccessOptions++;
+  if (buildCounterDataAccessOptions < 3) {
+  }
+  buildCounterDataAccessOptions--;
+}
+
 core.int buildCounterDataset = 0;
 buildDataset() {
   var o = new api.Dataset();
   buildCounterDataset++;
   if (buildCounterDataset < 3) {
     o.createTime = "foo";
     o.id = "foo";
     o.name = "foo";
     o.projectId = "foo";
   }
@@ skipping 47 matching lines @@
   buildCounterExperiment++;
   if (buildCounterExperiment < 3) {
     unittest.expect(o.instrumentModel, unittest.equals('foo'));
     unittest.expect(o.libraryId, unittest.equals('foo'));
     unittest.expect(o.platformUnit, unittest.equals('foo'));
     unittest.expect(o.sequencingCenter, unittest.equals('foo'));
   }
   buildCounterExperiment--;
 }
 
-buildUnnamed1777() {
+buildUnnamed1871() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1777(core.List<core.String> o) {
+checkUnnamed1871(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterExportReadGroupSetRequest = 0;
 buildExportReadGroupSetRequest() {
   var o = new api.ExportReadGroupSetRequest();
   buildCounterExportReadGroupSetRequest++;
   if (buildCounterExportReadGroupSetRequest < 3) {
     o.exportUri = "foo";
     o.projectId = "foo";
-    o.referenceNames = buildUnnamed1777();
+    o.referenceNames = buildUnnamed1871();
   }
   buildCounterExportReadGroupSetRequest--;
   return o;
 }
 
 checkExportReadGroupSetRequest(api.ExportReadGroupSetRequest o) {
   buildCounterExportReadGroupSetRequest++;
   if (buildCounterExportReadGroupSetRequest < 3) {
     unittest.expect(o.exportUri, unittest.equals('foo'));
     unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed1777(o.referenceNames);
+    checkUnnamed1871(o.referenceNames);
   }
   buildCounterExportReadGroupSetRequest--;
 }
 
-buildUnnamed1778() {
+buildUnnamed1872() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1778(core.List<core.String> o) {
+checkUnnamed1872(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 = buildUnnamed1778();
+    o.callSetIds = buildUnnamed1872();
     o.format = "foo";
     o.projectId = "foo";
   }
   buildCounterExportVariantSetRequest--;
   return o;
 }
 
 checkExportVariantSetRequest(api.ExportVariantSetRequest o) {
   buildCounterExportVariantSetRequest++;
   if (buildCounterExportVariantSetRequest < 3) {
     unittest.expect(o.bigqueryDataset, unittest.equals('foo'));
     unittest.expect(o.bigqueryTable, unittest.equals('foo'));
-    checkUnnamed1778(o.callSetIds);
+    checkUnnamed1872(o.callSetIds);
     unittest.expect(o.format, unittest.equals('foo'));
     unittest.expect(o.projectId, unittest.equals('foo'));
   }
   buildCounterExportVariantSetRequest--;
 }
 
-buildUnnamed1779() {
+core.int buildCounterGetIamPolicyRequest = 0;
+buildGetIamPolicyRequest() {
+  var o = new api.GetIamPolicyRequest();
+  buildCounterGetIamPolicyRequest++;
+  if (buildCounterGetIamPolicyRequest < 3) {
+  }
+  buildCounterGetIamPolicyRequest--;
+  return o;
+}
+
+checkGetIamPolicyRequest(api.GetIamPolicyRequest o) {
+  buildCounterGetIamPolicyRequest++;
+  if (buildCounterGetIamPolicyRequest < 3) {
+  }
+  buildCounterGetIamPolicyRequest--;
+}
+
+buildUnnamed1873() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1779(core.List<core.String> o) {
+checkUnnamed1873(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportReadGroupSetsRequest = 0;
 buildImportReadGroupSetsRequest() {
   var o = new api.ImportReadGroupSetsRequest();
   buildCounterImportReadGroupSetsRequest++;
   if (buildCounterImportReadGroupSetsRequest < 3) {
     o.datasetId = "foo";
     o.partitionStrategy = "foo";
     o.referenceSetId = "foo";
-    o.sourceUris = buildUnnamed1779();
+    o.sourceUris = buildUnnamed1873();
   }
   buildCounterImportReadGroupSetsRequest--;
   return o;
 }
 
 checkImportReadGroupSetsRequest(api.ImportReadGroupSetsRequest o) {
   buildCounterImportReadGroupSetsRequest++;
   if (buildCounterImportReadGroupSetsRequest < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.partitionStrategy, unittest.equals('foo'));
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
-    checkUnnamed1779(o.sourceUris);
+    checkUnnamed1873(o.sourceUris);
   }
   buildCounterImportReadGroupSetsRequest--;
 }
 
-buildUnnamed1780() {
+buildUnnamed1874() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1780(core.List<core.String> o) {
+checkUnnamed1874(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportReadGroupSetsResponse = 0;
 buildImportReadGroupSetsResponse() {
   var o = new api.ImportReadGroupSetsResponse();
   buildCounterImportReadGroupSetsResponse++;
   if (buildCounterImportReadGroupSetsResponse < 3) {
-    o.readGroupSetIds = buildUnnamed1780();
+    o.readGroupSetIds = buildUnnamed1874();
   }
   buildCounterImportReadGroupSetsResponse--;
   return o;
 }
 
 checkImportReadGroupSetsResponse(api.ImportReadGroupSetsResponse o) {
   buildCounterImportReadGroupSetsResponse++;
   if (buildCounterImportReadGroupSetsResponse < 3) {
-    checkUnnamed1780(o.readGroupSetIds);
+    checkUnnamed1874(o.readGroupSetIds);
   }
   buildCounterImportReadGroupSetsResponse--;
 }
 
-buildUnnamed1781() {
+buildUnnamed1875() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1781(core.List<core.String> o) {
+checkUnnamed1875(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.normalizeReferenceNames = true;
-    o.sourceUris = buildUnnamed1781();
+    o.sourceUris = buildUnnamed1875();
     o.variantSetId = "foo";
   }
   buildCounterImportVariantsRequest--;
   return o;
 }
 
 checkImportVariantsRequest(api.ImportVariantsRequest o) {
   buildCounterImportVariantsRequest++;
   if (buildCounterImportVariantsRequest < 3) {
     unittest.expect(o.format, unittest.equals('foo'));
     unittest.expect(o.normalizeReferenceNames, unittest.isTrue);
-    checkUnnamed1781(o.sourceUris);
+    checkUnnamed1875(o.sourceUris);
     unittest.expect(o.variantSetId, unittest.equals('foo'));
   }
   buildCounterImportVariantsRequest--;
 }
 
-buildUnnamed1782() {
+buildUnnamed1876() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1782(core.List<core.String> o) {
+checkUnnamed1876(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterImportVariantsResponse = 0;
 buildImportVariantsResponse() {
   var o = new api.ImportVariantsResponse();
   buildCounterImportVariantsResponse++;
   if (buildCounterImportVariantsResponse < 3) {
-    o.callSetIds = buildUnnamed1782();
+    o.callSetIds = buildUnnamed1876();
   }
   buildCounterImportVariantsResponse--;
   return o;
 }
 
 checkImportVariantsResponse(api.ImportVariantsResponse o) {
   buildCounterImportVariantsResponse++;
   if (buildCounterImportVariantsResponse < 3) {
-    checkUnnamed1782(o.callSetIds);
+    checkUnnamed1876(o.callSetIds);
   }
   buildCounterImportVariantsResponse--;
 }
 
-buildUnnamed1783() {
+buildUnnamed1877() {
   var o = new core.List<api.CigarUnit>();
   o.add(buildCigarUnit());
   o.add(buildCigarUnit());
   return o;
 }
 
-checkUnnamed1783(core.List<api.CigarUnit> o) {
+checkUnnamed1877(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 = buildUnnamed1783();
+    o.cigar = buildUnnamed1877();
     o.mappingQuality = 42;
     o.position = buildPosition();
   }
   buildCounterLinearAlignment--;
   return o;
 }
 
 checkLinearAlignment(api.LinearAlignment o) {
   buildCounterLinearAlignment++;
   if (buildCounterLinearAlignment < 3) {
-    checkUnnamed1783(o.cigar);
+    checkUnnamed1877(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--;
 }
 
-buildUnnamed1784() {
+buildUnnamed1878() {
   var o = new core.List<api.CoverageBucket>();
   o.add(buildCoverageBucket());
   o.add(buildCoverageBucket());
   return o;
 }
 
-checkUnnamed1784(core.List<api.CoverageBucket> o) {
+checkUnnamed1878(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 = buildUnnamed1784();
+    o.coverageBuckets = buildUnnamed1878();
     o.nextPageToken = "foo";
   }
   buildCounterListCoverageBucketsResponse--;
   return o;
 }
 
 checkListCoverageBucketsResponse(api.ListCoverageBucketsResponse o) {
   buildCounterListCoverageBucketsResponse++;
   if (buildCounterListCoverageBucketsResponse < 3) {
     unittest.expect(o.bucketWidth, unittest.equals('foo'));
-    checkUnnamed1784(o.coverageBuckets);
+    checkUnnamed1878(o.coverageBuckets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListCoverageBucketsResponse--;
 }
 
-buildUnnamed1785() {
+buildUnnamed1879() {
   var o = new core.List<api.Dataset>();
   o.add(buildDataset());
   o.add(buildDataset());
   return o;
 }
 
-checkUnnamed1785(core.List<api.Dataset> o) {
+checkUnnamed1879(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 = buildUnnamed1785();
+    o.datasets = buildUnnamed1879();
     o.nextPageToken = "foo";
   }
   buildCounterListDatasetsResponse--;
   return o;
 }
 
 checkListDatasetsResponse(api.ListDatasetsResponse o) {
   buildCounterListDatasetsResponse++;
   if (buildCounterListDatasetsResponse < 3) {
-    checkUnnamed1785(o.datasets);
+    checkUnnamed1879(o.datasets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListDatasetsResponse--;
 }
 
-buildUnnamed1786() {
+buildUnnamed1880() {
   var o = new core.List<api.Operation>();
   o.add(buildOperation());
   o.add(buildOperation());
   return o;
 }
 
-checkUnnamed1786(core.List<api.Operation> o) {
+checkUnnamed1880(core.List<api.Operation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperation(o[0]);
   checkOperation(o[1]);
 }
 
 core.int buildCounterListOperationsResponse = 0;
 buildListOperationsResponse() {
   var o = new api.ListOperationsResponse();
   buildCounterListOperationsResponse++;
   if (buildCounterListOperationsResponse < 3) {
     o.nextPageToken = "foo";
-    o.operations = buildUnnamed1786();
+    o.operations = buildUnnamed1880();
   }
   buildCounterListOperationsResponse--;
   return o;
 }
 
 checkListOperationsResponse(api.ListOperationsResponse o) {
   buildCounterListOperationsResponse++;
   if (buildCounterListOperationsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1786(o.operations);
+    checkUnnamed1880(o.operations);
   }
   buildCounterListOperationsResponse--;
 }
 
-buildUnnamed1787() {
+core.int buildCounterLogConfig = 0;
+buildLogConfig() {
+  var o = new api.LogConfig();
+  buildCounterLogConfig++;
+  if (buildCounterLogConfig < 3) {
+    o.cloudAudit = buildCloudAuditOptions();
+    o.counter = buildCounterOptions();
+    o.dataAccess = buildDataAccessOptions();
+  }
+  buildCounterLogConfig--;
+  return o;
+}
+
+checkLogConfig(api.LogConfig o) {
+  buildCounterLogConfig++;
+  if (buildCounterLogConfig < 3) {
+    checkCloudAuditOptions(o.cloudAudit);
+    checkCounterOptions(o.counter);
+    checkDataAccessOptions(o.dataAccess);
+  }
+  buildCounterLogConfig--;
+}
+
+buildUnnamed1881() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed1787(core.Map<core.String, core.Object> o) {
+checkUnnamed1881(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted3 = (o["x"]) as core.Map; unittest.expect(casted3, unittest.hasLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unittest.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["string"], unittest.equals('foo')); 
   var casted4 = (o["y"]) as core.Map; unittest.expect(casted4, unittest.hasLength(3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.expect(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1788() {
+buildUnnamed1882() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed1788(core.Map<core.String, core.Object> o) {
+checkUnnamed1882(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted5 = (o["x"]) as core.Map; unittest.expect(casted5, unittest.hasLength(3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expect(casted5["bool"], unittest.equals(true)); unittest.expect(casted5["string"], unittest.equals('foo')); 
   var casted6 = (o["y"]) as core.Map; unittest.expect(casted6, unittest.hasLength(3)); unittest.expect(casted6["list"], unittest.equals([1, 2, 3])); unittest.expect(casted6["bool"], unittest.equals(true)); unittest.expect(casted6["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterOperation = 0;
 buildOperation() {
   var o = new api.Operation();
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     o.done = true;
     o.error = buildStatus();
-    o.metadata = buildUnnamed1787();
+    o.metadata = buildUnnamed1881();
     o.name = "foo";
-    o.response = buildUnnamed1788();
+    o.response = buildUnnamed1882();
   }
   buildCounterOperation--;
   return o;
 }
 
 checkOperation(api.Operation o) {
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     unittest.expect(o.done, unittest.isTrue);
     checkStatus(o.error);
-    checkUnnamed1787(o.metadata);
+    checkUnnamed1881(o.metadata);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1788(o.response);
+    checkUnnamed1882(o.response);
   }
   buildCounterOperation--;
 }
 
 core.int buildCounterOperationEvent = 0;
 buildOperationEvent() {
   var o = new api.OperationEvent();
   buildCounterOperationEvent++;
   if (buildCounterOperationEvent < 3) {
     o.description = "foo";
   }
   buildCounterOperationEvent--;
   return o;
 }
 
 checkOperationEvent(api.OperationEvent o) {
   buildCounterOperationEvent++;
   if (buildCounterOperationEvent < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
   }
   buildCounterOperationEvent--;
 }
 
-buildUnnamed1789() {
+buildUnnamed1883() {
   var o = new core.List<api.OperationEvent>();
   o.add(buildOperationEvent());
   o.add(buildOperationEvent());
   return o;
 }
 
-checkUnnamed1789(core.List<api.OperationEvent> o) {
+checkUnnamed1883(core.List<api.OperationEvent> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationEvent(o[0]);
   checkOperationEvent(o[1]);
 }
 
-buildUnnamed1790() {
+buildUnnamed1884() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed1790(core.Map<core.String, core.Object> o) {
+checkUnnamed1884(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted7 = (o["x"]) as core.Map; unittest.expect(casted7, unittest.hasLength(3)); unittest.expect(casted7["list"], unittest.equals([1, 2, 3])); unittest.expect(casted7["bool"], unittest.equals(true)); unittest.expect(casted7["string"], unittest.equals('foo')); 
   var casted8 = (o["y"]) as core.Map; unittest.expect(casted8, unittest.hasLength(3)); unittest.expect(casted8["list"], unittest.equals([1, 2, 3])); unittest.expect(casted8["bool"], unittest.equals(true)); unittest.expect(casted8["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterOperationMetadata = 0;
 buildOperationMetadata() {
   var o = new api.OperationMetadata();
   buildCounterOperationMetadata++;
   if (buildCounterOperationMetadata < 3) {
     o.createTime = "foo";
-    o.events = buildUnnamed1789();
+    o.events = buildUnnamed1883();
     o.projectId = "foo";
-    o.request = buildUnnamed1790();
+    o.request = buildUnnamed1884();
   }
   buildCounterOperationMetadata--;
   return o;
 }
 
 checkOperationMetadata(api.OperationMetadata o) {
   buildCounterOperationMetadata++;
   if (buildCounterOperationMetadata < 3) {
     unittest.expect(o.createTime, unittest.equals('foo'));
-    checkUnnamed1789(o.events);
+    checkUnnamed1883(o.events);
     unittest.expect(o.projectId, unittest.equals('foo'));
-    checkUnnamed1790(o.request);
+    checkUnnamed1884(o.request);
   }
   buildCounterOperationMetadata--;
 }
 
+buildUnnamed1885() {
+  var o = new core.List<api.Binding>();
+  o.add(buildBinding());
+  o.add(buildBinding());
+  return o;
+}
+
+checkUnnamed1885(core.List<api.Binding> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkBinding(o[0]);
+  checkBinding(o[1]);
+}
+
+buildUnnamed1886() {
+  var o = new core.List<api.Rule>();
+  o.add(buildRule());
+  o.add(buildRule());
+  return o;
+}
+
+checkUnnamed1886(core.List<api.Rule> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkRule(o[0]);
+  checkRule(o[1]);
+}
+
+core.int buildCounterPolicy = 0;
+buildPolicy() {
+  var o = new api.Policy();
+  buildCounterPolicy++;
+  if (buildCounterPolicy < 3) {
+    o.bindings = buildUnnamed1885();
+    o.etag = "foo";
+    o.rules = buildUnnamed1886();
+    o.version = 42;
+  }
+  buildCounterPolicy--;
+  return o;
+}
+
+checkPolicy(api.Policy o) {
+  buildCounterPolicy++;
+  if (buildCounterPolicy < 3) {
+    checkUnnamed1885(o.bindings);
+    unittest.expect(o.etag, unittest.equals('foo'));
+    checkUnnamed1886(o.rules);
+    unittest.expect(o.version, unittest.equals(42));
+  }
+  buildCounterPolicy--;
+}
+
 core.int buildCounterPosition = 0;
 buildPosition() {
   var o = new api.Position();
   buildCounterPosition++;
   if (buildCounterPosition < 3) {
     o.position = "foo";
     o.referenceName = "foo";
     o.reverseStrand = true;
   }
   buildCounterPosition--;
@@ skipping 53 matching lines @@
 checkRange(api.Range o) {
   buildCounterRange++;
   if (buildCounterRange < 3) {
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterRange--;
 }
 
-buildUnnamed1791() {
+buildUnnamed1887() {
   var o = new core.List<core.int>();
   o.add(42);
   o.add(42);
   return o;
 }
 
-checkUnnamed1791(core.List<core.int> o) {
+checkUnnamed1887(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));
 }
 
-buildUnnamed1792() {
+buildUnnamed1888() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1792(core.List<core.Object> o) {
+checkUnnamed1888(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted9 = (o[0]) as core.Map; unittest.expect(casted9, unittest.hasLength(3)); unittest.expect(casted9["list"], unittest.equals([1, 2, 3])); unittest.expect(casted9["bool"], unittest.equals(true)); unittest.expect(casted9["string"], unittest.equals('foo')); 
   var casted10 = (o[1]) as core.Map; unittest.expect(casted10, unittest.hasLength(3)); unittest.expect(casted10["list"], unittest.equals([1, 2, 3])); unittest.expect(casted10["bool"], unittest.equals(true)); unittest.expect(casted10["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1793() {
+buildUnnamed1889() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1792();
-  o["y"] = buildUnnamed1792();
+  o["x"] = buildUnnamed1888();
+  o["y"] = buildUnnamed1888();
   return o;
 }
 
-checkUnnamed1793(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1889(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1792(o["x"]);
-  checkUnnamed1792(o["y"]);
+  checkUnnamed1888(o["x"]);
+  checkUnnamed1888(o["y"]);
 }
 
 core.int buildCounterRead = 0;
 buildRead() {
   var o = new api.Read();
   buildCounterRead++;
   if (buildCounterRead < 3) {
-    o.alignedQuality = buildUnnamed1791();
+    o.alignedQuality = buildUnnamed1887();
     o.alignedSequence = "foo";
     o.alignment = buildLinearAlignment();
     o.duplicateFragment = true;
     o.failedVendorQualityChecks = true;
     o.fragmentLength = 42;
     o.fragmentName = "foo";
     o.id = "foo";
-    o.info = buildUnnamed1793();
+    o.info = buildUnnamed1889();
     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) {
-    checkUnnamed1791(o.alignedQuality);
+    checkUnnamed1887(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'));
-    checkUnnamed1793(o.info);
+    checkUnnamed1889(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--;
 }
 
-buildUnnamed1794() {
+buildUnnamed1890() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1794(core.List<core.Object> o) {
+checkUnnamed1890(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted11 = (o[0]) as core.Map; unittest.expect(casted11, unittest.hasLength(3)); unittest.expect(casted11["list"], unittest.equals([1, 2, 3])); unittest.expect(casted11["bool"], unittest.equals(true)); unittest.expect(casted11["string"], unittest.equals('foo')); 
   var casted12 = (o[1]) as core.Map; unittest.expect(casted12, unittest.hasLength(3)); unittest.expect(casted12["list"], unittest.equals([1, 2, 3])); unittest.expect(casted12["bool"], unittest.equals(true)); unittest.expect(casted12["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1795() {
+buildUnnamed1891() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1794();
-  o["y"] = buildUnnamed1794();
+  o["x"] = buildUnnamed1890();
+  o["y"] = buildUnnamed1890();
   return o;
 }
 
-checkUnnamed1795(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1891(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1794(o["x"]);
-  checkUnnamed1794(o["y"]);
+  checkUnnamed1890(o["x"]);
+  checkUnnamed1890(o["y"]);
 }
 
-buildUnnamed1796() {
+buildUnnamed1892() {
   var o = new core.List<api.Program>();
   o.add(buildProgram());
   o.add(buildProgram());
   return o;
 }
 
-checkUnnamed1796(core.List<api.Program> o) {
+checkUnnamed1892(core.List<api.Program> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkProgram(o[0]);
   checkProgram(o[1]);
 }
 
 core.int buildCounterReadGroup = 0;
 buildReadGroup() {
   var o = new api.ReadGroup();
   buildCounterReadGroup++;
   if (buildCounterReadGroup < 3) {
     o.datasetId = "foo";
     o.description = "foo";
     o.experiment = buildExperiment();
     o.id = "foo";
-    o.info = buildUnnamed1795();
+    o.info = buildUnnamed1891();
     o.name = "foo";
     o.predictedInsertSize = 42;
-    o.programs = buildUnnamed1796();
+    o.programs = buildUnnamed1892();
     o.referenceSetId = "foo";
     o.sampleId = "foo";
   }
   buildCounterReadGroup--;
   return o;
 }
 
 checkReadGroup(api.ReadGroup o) {
   buildCounterReadGroup++;
   if (buildCounterReadGroup < 3) {
     unittest.expect(o.datasetId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     checkExperiment(o.experiment);
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1795(o.info);
+    checkUnnamed1891(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.predictedInsertSize, unittest.equals(42));
-    checkUnnamed1796(o.programs);
+    checkUnnamed1892(o.programs);
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
     unittest.expect(o.sampleId, unittest.equals('foo'));
   }
   buildCounterReadGroup--;
 }
 
-buildUnnamed1797() {
+buildUnnamed1893() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1797(core.List<core.Object> o) {
+checkUnnamed1893(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted13 = (o[0]) as core.Map; unittest.expect(casted13, unittest.hasLength(3)); unittest.expect(casted13["list"], unittest.equals([1, 2, 3])); unittest.expect(casted13["bool"], unittest.equals(true)); unittest.expect(casted13["string"], unittest.equals('foo')); 
   var casted14 = (o[1]) as core.Map; unittest.expect(casted14, unittest.hasLength(3)); unittest.expect(casted14["list"], unittest.equals([1, 2, 3])); unittest.expect(casted14["bool"], unittest.equals(true)); unittest.expect(casted14["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1798() {
+buildUnnamed1894() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1797();
-  o["y"] = buildUnnamed1797();
+  o["x"] = buildUnnamed1893();
+  o["y"] = buildUnnamed1893();
   return o;
 }
 
-checkUnnamed1798(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1894(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1797(o["x"]);
-  checkUnnamed1797(o["y"]);
+  checkUnnamed1893(o["x"]);
+  checkUnnamed1893(o["y"]);
 }
 
-buildUnnamed1799() {
+buildUnnamed1895() {
   var o = new core.List<api.ReadGroup>();
   o.add(buildReadGroup());
   o.add(buildReadGroup());
   return o;
 }
 
-checkUnnamed1799(core.List<api.ReadGroup> o) {
+checkUnnamed1895(core.List<api.ReadGroup> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkReadGroup(o[0]);
   checkReadGroup(o[1]);
 }
 
 core.int buildCounterReadGroupSet = 0;
 buildReadGroupSet() {
   var o = new api.ReadGroupSet();
   buildCounterReadGroupSet++;
   if (buildCounterReadGroupSet < 3) {
     o.datasetId = "foo";
     o.filename = "foo";
     o.id = "foo";
-    o.info = buildUnnamed1798();
+    o.info = buildUnnamed1894();
     o.name = "foo";
-    o.readGroups = buildUnnamed1799();
+    o.readGroups = buildUnnamed1895();
     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'));
-    checkUnnamed1798(o.info);
+    checkUnnamed1894(o.info);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1799(o.readGroups);
+    checkUnnamed1895(o.readGroups);
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
   }
   buildCounterReadGroupSet--;
 }
 
-buildUnnamed1800() {
+buildUnnamed1896() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1800(core.List<core.String> o) {
+checkUnnamed1896(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 = buildUnnamed1800();
+    o.sourceAccessions = buildUnnamed1896();
     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));
-    checkUnnamed1800(o.sourceAccessions);
+    checkUnnamed1896(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--;
 }
 
-buildUnnamed1801() {
+buildUnnamed1897() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1801(core.List<core.String> o) {
+checkUnnamed1897(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'));
 }
 
-buildUnnamed1802() {
+buildUnnamed1898() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1802(core.List<core.String> o) {
+checkUnnamed1898(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 = buildUnnamed1801();
-    o.sourceAccessions = buildUnnamed1802();
+    o.referenceIds = buildUnnamed1897();
+    o.sourceAccessions = buildUnnamed1898();
     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));
-    checkUnnamed1801(o.referenceIds);
-    checkUnnamed1802(o.sourceAccessions);
+    checkUnnamed1897(o.referenceIds);
+    checkUnnamed1898(o.sourceAccessions);
     unittest.expect(o.sourceUri, unittest.equals('foo'));
   }
   buildCounterReferenceSet--;
 }
 
-buildUnnamed1803() {
+buildUnnamed1899() {
+  var o = new core.List<api.Condition>();
+  o.add(buildCondition());
+  o.add(buildCondition());
+  return o;
+}
+
+checkUnnamed1899(core.List<api.Condition> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkCondition(o[0]);
+  checkCondition(o[1]);
+}
+
+buildUnnamed1900() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1803(core.List<core.String> o) {
+checkUnnamed1900(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'));
+}
+
+buildUnnamed1901() {
+  var o = new core.List<api.LogConfig>();
+  o.add(buildLogConfig());
+  o.add(buildLogConfig());
+  return o;
+}
+
+checkUnnamed1901(core.List<api.LogConfig> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkLogConfig(o[0]);
+  checkLogConfig(o[1]);
+}
+
+buildUnnamed1902() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1902(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'));
+}
+
+buildUnnamed1903() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1903(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 buildCounterRule = 0;
+buildRule() {
+  var o = new api.Rule();
+  buildCounterRule++;
+  if (buildCounterRule < 3) {
+    o.action = "foo";
+    o.conditions = buildUnnamed1899();
+    o.description = "foo";
+    o.in_ = buildUnnamed1900();
+    o.logConfig = buildUnnamed1901();
+    o.notIn = buildUnnamed1902();
+    o.permissions = buildUnnamed1903();
+  }
+  buildCounterRule--;
+  return o;
+}
+
+checkRule(api.Rule o) {
+  buildCounterRule++;
+  if (buildCounterRule < 3) {
+    unittest.expect(o.action, unittest.equals('foo'));
+    checkUnnamed1899(o.conditions);
+    unittest.expect(o.description, unittest.equals('foo'));
+    checkUnnamed1900(o.in_);
+    checkUnnamed1901(o.logConfig);
+    checkUnnamed1902(o.notIn);
+    checkUnnamed1903(o.permissions);
+  }
+  buildCounterRule--;
+}
+
+buildUnnamed1904() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1904(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 = buildUnnamed1803();
+    o.variantSetIds = buildUnnamed1904();
   }
   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'));
-    checkUnnamed1803(o.variantSetIds);
+    checkUnnamed1904(o.variantSetIds);
   }
   buildCounterSearchCallSetsRequest--;
 }
 
-buildUnnamed1804() {
+buildUnnamed1905() {
   var o = new core.List<api.CallSet>();
   o.add(buildCallSet());
   o.add(buildCallSet());
   return o;
 }
 
-checkUnnamed1804(core.List<api.CallSet> o) {
+checkUnnamed1905(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 = buildUnnamed1804();
+    o.callSets = buildUnnamed1905();
     o.nextPageToken = "foo";
   }
   buildCounterSearchCallSetsResponse--;
   return o;
 }
 
 checkSearchCallSetsResponse(api.SearchCallSetsResponse o) {
   buildCounterSearchCallSetsResponse++;
   if (buildCounterSearchCallSetsResponse < 3) {
-    checkUnnamed1804(o.callSets);
+    checkUnnamed1905(o.callSets);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchCallSetsResponse--;
 }
 
-buildUnnamed1805() {
+buildUnnamed1906() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1805(core.List<core.String> o) {
+checkUnnamed1906(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 = buildUnnamed1805();
+    o.datasetIds = buildUnnamed1906();
     o.name = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchReadGroupSetsRequest--;
   return o;
 }
 
 checkSearchReadGroupSetsRequest(api.SearchReadGroupSetsRequest o) {
   buildCounterSearchReadGroupSetsRequest++;
   if (buildCounterSearchReadGroupSetsRequest < 3) {
-    checkUnnamed1805(o.datasetIds);
+    checkUnnamed1906(o.datasetIds);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchReadGroupSetsRequest--;
 }
 
-buildUnnamed1806() {
+buildUnnamed1907() {
   var o = new core.List<api.ReadGroupSet>();
   o.add(buildReadGroupSet());
   o.add(buildReadGroupSet());
   return o;
 }
 
-checkUnnamed1806(core.List<api.ReadGroupSet> o) {
+checkUnnamed1907(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 = buildUnnamed1806();
+    o.readGroupSets = buildUnnamed1907();
   }
   buildCounterSearchReadGroupSetsResponse--;
   return o;
 }
 
 checkSearchReadGroupSetsResponse(api.SearchReadGroupSetsResponse o) {
   buildCounterSearchReadGroupSetsResponse++;
   if (buildCounterSearchReadGroupSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1806(o.readGroupSets);
+    checkUnnamed1907(o.readGroupSets);
   }
   buildCounterSearchReadGroupSetsResponse--;
 }
 
-buildUnnamed1807() {
+buildUnnamed1908() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1807(core.List<core.String> o) {
+checkUnnamed1908(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'));
 }
 
-buildUnnamed1808() {
+buildUnnamed1909() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1808(core.List<core.String> o) {
+checkUnnamed1909(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterSearchReadsRequest = 0;
 buildSearchReadsRequest() {
   var o = new api.SearchReadsRequest();
   buildCounterSearchReadsRequest++;
   if (buildCounterSearchReadsRequest < 3) {
     o.end = "foo";
     o.pageSize = 42;
     o.pageToken = "foo";
-    o.readGroupIds = buildUnnamed1807();
-    o.readGroupSetIds = buildUnnamed1808();
+    o.readGroupIds = buildUnnamed1908();
+    o.readGroupSetIds = buildUnnamed1909();
     o.referenceName = "foo";
     o.start = "foo";
   }
   buildCounterSearchReadsRequest--;
   return o;
 }
 
 checkSearchReadsRequest(api.SearchReadsRequest o) {
   buildCounterSearchReadsRequest++;
   if (buildCounterSearchReadsRequest < 3) {
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
-    checkUnnamed1807(o.readGroupIds);
-    checkUnnamed1808(o.readGroupSetIds);
+    checkUnnamed1908(o.readGroupIds);
+    checkUnnamed1909(o.readGroupSetIds);
     unittest.expect(o.referenceName, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterSearchReadsRequest--;
 }
 
-buildUnnamed1809() {
+buildUnnamed1910() {
   var o = new core.List<api.Read>();
   o.add(buildRead());
   o.add(buildRead());
   return o;
 }
 
-checkUnnamed1809(core.List<api.Read> o) {
+checkUnnamed1910(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 = buildUnnamed1809();
+    o.alignments = buildUnnamed1910();
     o.nextPageToken = "foo";
   }
   buildCounterSearchReadsResponse--;
   return o;
 }
 
 checkSearchReadsResponse(api.SearchReadsResponse o) {
   buildCounterSearchReadsResponse++;
   if (buildCounterSearchReadsResponse < 3) {
-    checkUnnamed1809(o.alignments);
+    checkUnnamed1910(o.alignments);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterSearchReadsResponse--;
 }
 
-buildUnnamed1810() {
+buildUnnamed1911() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1810(core.List<core.String> o) {
+checkUnnamed1911(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'));
 }
 
-buildUnnamed1811() {
+buildUnnamed1912() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1811(core.List<core.String> o) {
+checkUnnamed1912(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 = buildUnnamed1810();
+    o.accessions = buildUnnamed1911();
     o.assemblyId = "foo";
-    o.md5checksums = buildUnnamed1811();
+    o.md5checksums = buildUnnamed1912();
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchReferenceSetsRequest--;
   return o;
 }
 
 checkSearchReferenceSetsRequest(api.SearchReferenceSetsRequest o) {
   buildCounterSearchReferenceSetsRequest++;
   if (buildCounterSearchReferenceSetsRequest < 3) {
-    checkUnnamed1810(o.accessions);
+    checkUnnamed1911(o.accessions);
     unittest.expect(o.assemblyId, unittest.equals('foo'));
-    checkUnnamed1811(o.md5checksums);
+    checkUnnamed1912(o.md5checksums);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchReferenceSetsRequest--;
 }
 
-buildUnnamed1812() {
+buildUnnamed1913() {
   var o = new core.List<api.ReferenceSet>();
   o.add(buildReferenceSet());
   o.add(buildReferenceSet());
   return o;
 }
 
-checkUnnamed1812(core.List<api.ReferenceSet> o) {
+checkUnnamed1913(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 = buildUnnamed1812();
+    o.referenceSets = buildUnnamed1913();
   }
   buildCounterSearchReferenceSetsResponse--;
   return o;
 }
 
 checkSearchReferenceSetsResponse(api.SearchReferenceSetsResponse o) {
   buildCounterSearchReferenceSetsResponse++;
   if (buildCounterSearchReferenceSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1812(o.referenceSets);
+    checkUnnamed1913(o.referenceSets);
   }
   buildCounterSearchReferenceSetsResponse--;
 }
 
-buildUnnamed1813() {
+buildUnnamed1914() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1813(core.List<core.String> o) {
+checkUnnamed1914(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'));
 }
 
-buildUnnamed1814() {
+buildUnnamed1915() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1814(core.List<core.String> o) {
+checkUnnamed1915(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 = buildUnnamed1813();
-    o.md5checksums = buildUnnamed1814();
+    o.accessions = buildUnnamed1914();
+    o.md5checksums = buildUnnamed1915();
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceSetId = "foo";
   }
   buildCounterSearchReferencesRequest--;
   return o;
 }
 
 checkSearchReferencesRequest(api.SearchReferencesRequest o) {
   buildCounterSearchReferencesRequest++;
   if (buildCounterSearchReferencesRequest < 3) {
-    checkUnnamed1813(o.accessions);
-    checkUnnamed1814(o.md5checksums);
+    checkUnnamed1914(o.accessions);
+    checkUnnamed1915(o.md5checksums);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
     unittest.expect(o.referenceSetId, unittest.equals('foo'));
   }
   buildCounterSearchReferencesRequest--;
 }
 
-buildUnnamed1815() {
+buildUnnamed1916() {
   var o = new core.List<api.Reference>();
   o.add(buildReference());
   o.add(buildReference());
   return o;
 }
 
-checkUnnamed1815(core.List<api.Reference> o) {
+checkUnnamed1916(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 = buildUnnamed1815();
+    o.references = buildUnnamed1916();
   }
   buildCounterSearchReferencesResponse--;
   return o;
 }
 
 checkSearchReferencesResponse(api.SearchReferencesResponse o) {
   buildCounterSearchReferencesResponse++;
   if (buildCounterSearchReferencesResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1815(o.references);
+    checkUnnamed1916(o.references);
   }
   buildCounterSearchReferencesResponse--;
 }
 
-buildUnnamed1816() {
+buildUnnamed1917() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1816(core.List<core.String> o) {
+checkUnnamed1917(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 = buildUnnamed1816();
+    o.datasetIds = buildUnnamed1917();
     o.pageSize = 42;
     o.pageToken = "foo";
   }
   buildCounterSearchVariantSetsRequest--;
   return o;
 }
 
 checkSearchVariantSetsRequest(api.SearchVariantSetsRequest o) {
   buildCounterSearchVariantSetsRequest++;
   if (buildCounterSearchVariantSetsRequest < 3) {
-    checkUnnamed1816(o.datasetIds);
+    checkUnnamed1917(o.datasetIds);
     unittest.expect(o.pageSize, unittest.equals(42));
     unittest.expect(o.pageToken, unittest.equals('foo'));
   }
   buildCounterSearchVariantSetsRequest--;
 }
 
-buildUnnamed1817() {
+buildUnnamed1918() {
   var o = new core.List<api.VariantSet>();
   o.add(buildVariantSet());
   o.add(buildVariantSet());
   return o;
 }
 
-checkUnnamed1817(core.List<api.VariantSet> o) {
+checkUnnamed1918(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 = buildUnnamed1817();
+    o.variantSets = buildUnnamed1918();
   }
   buildCounterSearchVariantSetsResponse--;
   return o;
 }
 
 checkSearchVariantSetsResponse(api.SearchVariantSetsResponse o) {
   buildCounterSearchVariantSetsResponse++;
   if (buildCounterSearchVariantSetsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1817(o.variantSets);
+    checkUnnamed1918(o.variantSets);
   }
   buildCounterSearchVariantSetsResponse--;
 }
 
-buildUnnamed1818() {
+buildUnnamed1919() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1818(core.List<core.String> o) {
+checkUnnamed1919(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'));
 }
 
-buildUnnamed1819() {
+buildUnnamed1920() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1819(core.List<core.String> o) {
+checkUnnamed1920(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 = buildUnnamed1818();
+    o.callSetIds = buildUnnamed1919();
     o.end = "foo";
     o.maxCalls = 42;
     o.pageSize = 42;
     o.pageToken = "foo";
     o.referenceName = "foo";
     o.start = "foo";
     o.variantName = "foo";
-    o.variantSetIds = buildUnnamed1819();
+    o.variantSetIds = buildUnnamed1920();
   }
   buildCounterSearchVariantsRequest--;
   return o;
 }
 
 checkSearchVariantsRequest(api.SearchVariantsRequest o) {
   buildCounterSearchVariantsRequest++;
   if (buildCounterSearchVariantsRequest < 3) {
-    checkUnnamed1818(o.callSetIds);
+    checkUnnamed1919(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'));
-    checkUnnamed1819(o.variantSetIds);
+    checkUnnamed1920(o.variantSetIds);
   }
   buildCounterSearchVariantsRequest--;
 }
 
-buildUnnamed1820() {
+buildUnnamed1921() {
   var o = new core.List<api.Variant>();
   o.add(buildVariant());
   o.add(buildVariant());
   return o;
 }
 
-checkUnnamed1820(core.List<api.Variant> o) {
+checkUnnamed1921(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 = buildUnnamed1820();
+    o.variants = buildUnnamed1921();
   }
   buildCounterSearchVariantsResponse--;
   return o;
 }
 
 checkSearchVariantsResponse(api.SearchVariantsResponse o) {
   buildCounterSearchVariantsResponse++;
   if (buildCounterSearchVariantsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1820(o.variants);
+    checkUnnamed1921(o.variants);
   }
   buildCounterSearchVariantsResponse--;
 }
 
-buildUnnamed1821() {
+core.int buildCounterSetIamPolicyRequest = 0;
+buildSetIamPolicyRequest() {
+  var o = new api.SetIamPolicyRequest();
+  buildCounterSetIamPolicyRequest++;
+  if (buildCounterSetIamPolicyRequest < 3) {
+    o.policy = buildPolicy();
+  }
+  buildCounterSetIamPolicyRequest--;
+  return o;
+}
+
+checkSetIamPolicyRequest(api.SetIamPolicyRequest o) {
+  buildCounterSetIamPolicyRequest++;
+  if (buildCounterSetIamPolicyRequest < 3) {
+    checkPolicy(o.policy);
+  }
+  buildCounterSetIamPolicyRequest--;
+}
+
+buildUnnamed1922() {
   var o = new core.Map<core.String, core.Object>();
   o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
   return o;
 }
 
-checkUnnamed1821(core.Map<core.String, core.Object> o) {
+checkUnnamed1922(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted15 = (o["x"]) as core.Map; unittest.expect(casted15, unittest.hasLength(3)); unittest.expect(casted15["list"], unittest.equals([1, 2, 3])); unittest.expect(casted15["bool"], unittest.equals(true)); unittest.expect(casted15["string"], unittest.equals('foo')); 
   var casted16 = (o["y"]) as core.Map; unittest.expect(casted16, unittest.hasLength(3)); unittest.expect(casted16["list"], unittest.equals([1, 2, 3])); unittest.expect(casted16["bool"], unittest.equals(true)); unittest.expect(casted16["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1822() {
+buildUnnamed1923() {
   var o = new core.List<core.Map<core.String, core.Object>>();
-  o.add(buildUnnamed1821());
-  o.add(buildUnnamed1821());
+  o.add(buildUnnamed1922());
+  o.add(buildUnnamed1922());
   return o;
 }
 
-checkUnnamed1822(core.List<core.Map<core.String, core.Object>> o) {
+checkUnnamed1923(core.List<core.Map<core.String, core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1821(o[0]);
-  checkUnnamed1821(o[1]);
+  checkUnnamed1922(o[0]);
+  checkUnnamed1922(o[1]);
 }
 
 core.int buildCounterStatus = 0;
 buildStatus() {
   var o = new api.Status();
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     o.code = 42;
-    o.details = buildUnnamed1822();
+    o.details = buildUnnamed1923();
     o.message = "foo";
   }
   buildCounterStatus--;
   return o;
 }
 
 checkStatus(api.Status o) {
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     unittest.expect(o.code, unittest.equals(42));
-    checkUnnamed1822(o.details);
+    checkUnnamed1923(o.details);
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterStatus--;
 }
 
+buildUnnamed1924() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1924(core.List<core.String> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  unittest.expect(o[0], unittest.equals('foo'));
+  unittest.expect(o[1], unittest.equals('foo'));
+}
+
+core.int buildCounterTestIamPermissionsRequest = 0;
+buildTestIamPermissionsRequest() {
+  var o = new api.TestIamPermissionsRequest();
+  buildCounterTestIamPermissionsRequest++;
+  if (buildCounterTestIamPermissionsRequest < 3) {
+    o.permissions = buildUnnamed1924();
+  }
+  buildCounterTestIamPermissionsRequest--;
+  return o;
+}
+
+checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
+  buildCounterTestIamPermissionsRequest++;
+  if (buildCounterTestIamPermissionsRequest < 3) {
+    checkUnnamed1924(o.permissions);
+  }
+  buildCounterTestIamPermissionsRequest--;
+}
+
+buildUnnamed1925() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1925(core.List<core.String> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  unittest.expect(o[0], unittest.equals('foo'));
+  unittest.expect(o[1], unittest.equals('foo'));
+}
+
+core.int buildCounterTestIamPermissionsResponse = 0;
+buildTestIamPermissionsResponse() {
+  var o = new api.TestIamPermissionsResponse();
+  buildCounterTestIamPermissionsResponse++;
+  if (buildCounterTestIamPermissionsResponse < 3) {
+    o.permissions = buildUnnamed1925();
+  }
+  buildCounterTestIamPermissionsResponse--;
+  return o;
+}
+
+checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
+  buildCounterTestIamPermissionsResponse++;
+  if (buildCounterTestIamPermissionsResponse < 3) {
+    checkUnnamed1925(o.permissions);
+  }
+  buildCounterTestIamPermissionsResponse--;
+}
+
 core.int buildCounterUndeleteDatasetRequest = 0;
 buildUndeleteDatasetRequest() {
   var o = new api.UndeleteDatasetRequest();
   buildCounterUndeleteDatasetRequest++;
   if (buildCounterUndeleteDatasetRequest < 3) {
   }
   buildCounterUndeleteDatasetRequest--;
   return o;
 }
 
 checkUndeleteDatasetRequest(api.UndeleteDatasetRequest o) {
   buildCounterUndeleteDatasetRequest++;
   if (buildCounterUndeleteDatasetRequest < 3) {
   }
   buildCounterUndeleteDatasetRequest--;
 }
 
-buildUnnamed1823() {
+buildUnnamed1926() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1823(core.List<core.String> o) {
+checkUnnamed1926(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'));
 }
 
-buildUnnamed1824() {
+buildUnnamed1927() {
   var o = new core.List<api.VariantCall>();
   o.add(buildVariantCall());
   o.add(buildVariantCall());
   return o;
 }
 
-checkUnnamed1824(core.List<api.VariantCall> o) {
+checkUnnamed1927(core.List<api.VariantCall> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariantCall(o[0]);
   checkVariantCall(o[1]);
 }
 
-buildUnnamed1825() {
+buildUnnamed1928() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1825(core.List<core.String> o) {
+checkUnnamed1928(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'));
 }
 
-buildUnnamed1826() {
+buildUnnamed1929() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1826(core.List<core.Object> o) {
+checkUnnamed1929(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted17 = (o[0]) as core.Map; unittest.expect(casted17, unittest.hasLength(3)); unittest.expect(casted17["list"], unittest.equals([1, 2, 3])); unittest.expect(casted17["bool"], unittest.equals(true)); unittest.expect(casted17["string"], unittest.equals('foo')); 
   var casted18 = (o[1]) as core.Map; unittest.expect(casted18, unittest.hasLength(3)); unittest.expect(casted18["list"], unittest.equals([1, 2, 3])); unittest.expect(casted18["bool"], unittest.equals(true)); unittest.expect(casted18["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1827() {
+buildUnnamed1930() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1826();
-  o["y"] = buildUnnamed1826();
+  o["x"] = buildUnnamed1929();
+  o["y"] = buildUnnamed1929();
   return o;
 }
 
-checkUnnamed1827(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1930(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1826(o["x"]);
-  checkUnnamed1826(o["y"]);
+  checkUnnamed1929(o["x"]);
+  checkUnnamed1929(o["y"]);
 }
 
-buildUnnamed1828() {
+buildUnnamed1931() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1828(core.List<core.String> o) {
+checkUnnamed1931(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 = buildUnnamed1823();
-    o.calls = buildUnnamed1824();
+    o.alternateBases = buildUnnamed1926();
+    o.calls = buildUnnamed1927();
     o.created = "foo";
     o.end = "foo";
-    o.filter = buildUnnamed1825();
+    o.filter = buildUnnamed1928();
     o.id = "foo";
-    o.info = buildUnnamed1827();
-    o.names = buildUnnamed1828();
+    o.info = buildUnnamed1930();
+    o.names = buildUnnamed1931();
     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) {
-    checkUnnamed1823(o.alternateBases);
-    checkUnnamed1824(o.calls);
+    checkUnnamed1926(o.alternateBases);
+    checkUnnamed1927(o.calls);
     unittest.expect(o.created, unittest.equals('foo'));
     unittest.expect(o.end, unittest.equals('foo'));
-    checkUnnamed1825(o.filter);
+    checkUnnamed1928(o.filter);
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1827(o.info);
-    checkUnnamed1828(o.names);
+    checkUnnamed1930(o.info);
+    checkUnnamed1931(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--;
 }
 
-buildUnnamed1829() {
+buildUnnamed1932() {
   var o = new core.List<core.int>();
   o.add(42);
   o.add(42);
   return o;
 }
 
-checkUnnamed1829(core.List<core.int> o) {
+checkUnnamed1932(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));
 }
 
-buildUnnamed1830() {
+buildUnnamed1933() {
   var o = new core.List<core.double>();
   o.add(42.0);
   o.add(42.0);
   return o;
 }
 
-checkUnnamed1830(core.List<core.double> o) {
+checkUnnamed1933(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));
 }
 
-buildUnnamed1831() {
+buildUnnamed1934() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1831(core.List<core.Object> o) {
+checkUnnamed1934(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted19 = (o[0]) as core.Map; unittest.expect(casted19, unittest.hasLength(3)); unittest.expect(casted19["list"], unittest.equals([1, 2, 3])); unittest.expect(casted19["bool"], unittest.equals(true)); unittest.expect(casted19["string"], unittest.equals('foo')); 
   var casted20 = (o[1]) as core.Map; unittest.expect(casted20, unittest.hasLength(3)); unittest.expect(casted20["list"], unittest.equals([1, 2, 3])); unittest.expect(casted20["bool"], unittest.equals(true)); unittest.expect(casted20["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1832() {
+buildUnnamed1935() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1831();
-  o["y"] = buildUnnamed1831();
+  o["x"] = buildUnnamed1934();
+  o["y"] = buildUnnamed1934();
   return o;
 }
 
-checkUnnamed1832(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1935(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1831(o["x"]);
-  checkUnnamed1831(o["y"]);
+  checkUnnamed1934(o["x"]);
+  checkUnnamed1934(o["y"]);
 }
 
 core.int buildCounterVariantCall = 0;
 buildVariantCall() {
   var o = new api.VariantCall();
   buildCounterVariantCall++;
   if (buildCounterVariantCall < 3) {
     o.callSetId = "foo";
     o.callSetName = "foo";
-    o.genotype = buildUnnamed1829();
-    o.genotypeLikelihood = buildUnnamed1830();
-    o.info = buildUnnamed1832();
+    o.genotype = buildUnnamed1932();
+    o.genotypeLikelihood = buildUnnamed1933();
+    o.info = buildUnnamed1935();
     o.phaseset = "foo";
   }
   buildCounterVariantCall--;
   return o;
 }
 
 checkVariantCall(api.VariantCall o) {
   buildCounterVariantCall++;
   if (buildCounterVariantCall < 3) {
     unittest.expect(o.callSetId, unittest.equals('foo'));
     unittest.expect(o.callSetName, unittest.equals('foo'));
-    checkUnnamed1829(o.genotype);
-    checkUnnamed1830(o.genotypeLikelihood);
-    checkUnnamed1832(o.info);
+    checkUnnamed1932(o.genotype);
+    checkUnnamed1933(o.genotypeLikelihood);
+    checkUnnamed1935(o.info);
     unittest.expect(o.phaseset, unittest.equals('foo'));
   }
   buildCounterVariantCall--;
 }
 
-buildUnnamed1833() {
+buildUnnamed1936() {
   var o = new core.List<api.VariantSetMetadata>();
   o.add(buildVariantSetMetadata());
   o.add(buildVariantSetMetadata());
   return o;
 }
 
-checkUnnamed1833(core.List<api.VariantSetMetadata> o) {
+checkUnnamed1936(core.List<api.VariantSetMetadata> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVariantSetMetadata(o[0]);
   checkVariantSetMetadata(o[1]);
 }
 
-buildUnnamed1834() {
+buildUnnamed1937() {
   var o = new core.List<api.ReferenceBound>();
   o.add(buildReferenceBound());
   o.add(buildReferenceBound());
   return o;
 }
 
-checkUnnamed1834(core.List<api.ReferenceBound> o) {
+checkUnnamed1937(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 = buildUnnamed1833();
-    o.referenceBounds = buildUnnamed1834();
+    o.metadata = buildUnnamed1936();
+    o.referenceBounds = buildUnnamed1937();
   }
   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'));
-    checkUnnamed1833(o.metadata);
-    checkUnnamed1834(o.referenceBounds);
+    checkUnnamed1936(o.metadata);
+    checkUnnamed1937(o.referenceBounds);
   }
   buildCounterVariantSet--;
 }
 
-buildUnnamed1835() {
+buildUnnamed1938() {
   var o = new core.List<core.Object>();
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
   return o;
 }
 
-checkUnnamed1835(core.List<core.Object> o) {
+checkUnnamed1938(core.List<core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted21 = (o[0]) as core.Map; unittest.expect(casted21, unittest.hasLength(3)); unittest.expect(casted21["list"], unittest.equals([1, 2, 3])); unittest.expect(casted21["bool"], unittest.equals(true)); unittest.expect(casted21["string"], unittest.equals('foo')); 
   var casted22 = (o[1]) as core.Map; unittest.expect(casted22, unittest.hasLength(3)); unittest.expect(casted22["list"], unittest.equals([1, 2, 3])); unittest.expect(casted22["bool"], unittest.equals(true)); unittest.expect(casted22["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1836() {
+buildUnnamed1939() {
   var o = new core.Map<core.String, core.List<core.Object>>();
-  o["x"] = buildUnnamed1835();
-  o["y"] = buildUnnamed1835();
+  o["x"] = buildUnnamed1938();
+  o["y"] = buildUnnamed1938();
   return o;
 }
 
-checkUnnamed1836(core.Map<core.String, core.List<core.Object>> o) {
+checkUnnamed1939(core.Map<core.String, core.List<core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1835(o["x"]);
-  checkUnnamed1835(o["y"]);
+  checkUnnamed1938(o["x"]);
+  checkUnnamed1938(o["y"]);
 }
 
 core.int buildCounterVariantSetMetadata = 0;
 buildVariantSetMetadata() {
   var o = new api.VariantSetMetadata();
   buildCounterVariantSetMetadata++;
   if (buildCounterVariantSetMetadata < 3) {
     o.description = "foo";
     o.id = "foo";
-    o.info = buildUnnamed1836();
+    o.info = buildUnnamed1939();
     o.key = "foo";
     o.number = "foo";
     o.type = "foo";
     o.value = "foo";
   }
   buildCounterVariantSetMetadata--;
   return o;
 }
 
 checkVariantSetMetadata(api.VariantSetMetadata o) {
   buildCounterVariantSetMetadata++;
   if (buildCounterVariantSetMetadata < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1836(o.info);
+    checkUnnamed1939(o.info);
     unittest.expect(o.key, unittest.equals('foo'));
     unittest.expect(o.number, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
     unittest.expect(o.value, unittest.equals('foo'));
   }
   buildCounterVariantSetMetadata--;
 }
 
 
 main() {
+  unittest.group("obj-schema-Binding", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBinding();
+      var od = new api.Binding.fromJson(o.toJson());
+      checkBinding(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-CancelOperationRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildCancelOperationRequest();
       var od = new api.CancelOperationRequest.fromJson(o.toJson());
       checkCancelOperationRequest(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-CloudAuditOptions", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCloudAuditOptions();
+      var od = new api.CloudAuditOptions.fromJson(o.toJson());
+      checkCloudAuditOptions(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Condition", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCondition();
+      var od = new api.Condition.fromJson(o.toJson());
+      checkCondition(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-CounterOptions", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCounterOptions();
+      var od = new api.CounterOptions.fromJson(o.toJson());
+      checkCounterOptions(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-DataAccessOptions", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDataAccessOptions();
+      var od = new api.DataAccessOptions.fromJson(o.toJson());
+      checkDataAccessOptions(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Dataset", () {
     unittest.test("to-json--from-json", () {
       var o = buildDataset();
       var od = new api.Dataset.fromJson(o.toJson());
       checkDataset(od);
     });
   });
 
 
   unittest.group("obj-schema-Empty", () {
@@ skipping 25 matching lines @@
 
   unittest.group("obj-schema-ExportVariantSetRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildExportVariantSetRequest();
       var od = new api.ExportVariantSetRequest.fromJson(o.toJson());
       checkExportVariantSetRequest(od);
     });
   });
 
 
+  unittest.group("obj-schema-GetIamPolicyRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGetIamPolicyRequest();
+      var od = new api.GetIamPolicyRequest.fromJson(o.toJson());
+      checkGetIamPolicyRequest(od);
+    });
+  });
+
+
   unittest.group("obj-schema-ImportReadGroupSetsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildImportReadGroupSetsRequest();
       var od = new api.ImportReadGroupSetsRequest.fromJson(o.toJson());
       checkImportReadGroupSetsRequest(od);
     });
   });
 
 
   unittest.group("obj-schema-ImportReadGroupSetsResponse", () {
@@ skipping 61 matching lines @@
 
   unittest.group("obj-schema-ListOperationsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListOperationsResponse();
       var od = new api.ListOperationsResponse.fromJson(o.toJson());
       checkListOperationsResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-LogConfig", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildLogConfig();
+      var od = new api.LogConfig.fromJson(o.toJson());
+      checkLogConfig(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Operation", () {
     unittest.test("to-json--from-json", () {
       var o = buildOperation();
       var od = new api.Operation.fromJson(o.toJson());
       checkOperation(od);
     });
   });
 
 
   unittest.group("obj-schema-OperationEvent", () {
     unittest.test("to-json--from-json", () {
       var o = buildOperationEvent();
       var od = new api.OperationEvent.fromJson(o.toJson());
       checkOperationEvent(od);
     });
   });
 
 
   unittest.group("obj-schema-OperationMetadata", () {
     unittest.test("to-json--from-json", () {
       var o = buildOperationMetadata();
       var od = new api.OperationMetadata.fromJson(o.toJson());
       checkOperationMetadata(od);
     });
   });
 
 
+  unittest.group("obj-schema-Policy", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildPolicy();
+      var od = new api.Policy.fromJson(o.toJson());
+      checkPolicy(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-Program", () {
@@ skipping 61 matching lines @@
 
   unittest.group("obj-schema-ReferenceSet", () {
     unittest.test("to-json--from-json", () {
       var o = buildReferenceSet();
       var od = new api.ReferenceSet.fromJson(o.toJson());
       checkReferenceSet(od);
     });
   });
 
 
+  unittest.group("obj-schema-Rule", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRule();
+      var od = new api.Rule.fromJson(o.toJson());
+      checkRule(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);
     });
   });
 
 
   unittest.group("obj-schema-SearchCallSetsResponse", () {
@@ skipping 106 matching lines @@
 
   unittest.group("obj-schema-SearchVariantsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchVariantsResponse();
       var od = new api.SearchVariantsResponse.fromJson(o.toJson());
       checkSearchVariantsResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-SetIamPolicyRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSetIamPolicyRequest();
+      var od = new api.SetIamPolicyRequest.fromJson(o.toJson());
+      checkSetIamPolicyRequest(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Status", () {
     unittest.test("to-json--from-json", () {
       var o = buildStatus();
       var od = new api.Status.fromJson(o.toJson());
       checkStatus(od);
     });
   });
 
 
+  unittest.group("obj-schema-TestIamPermissionsRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTestIamPermissionsRequest();
+      var od = new api.TestIamPermissionsRequest.fromJson(o.toJson());
+      checkTestIamPermissionsRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TestIamPermissionsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTestIamPermissionsResponse();
+      var od = new api.TestIamPermissionsResponse.fromJson(o.toJson());
+      checkTestIamPermissionsResponse(od);
+    });
+  });
+
+
   unittest.group("obj-schema-UndeleteDatasetRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildUndeleteDatasetRequest();
       var od = new api.UndeleteDatasetRequest.fromJson(o.toJson());
       checkUndeleteDatasetRequest(od);
     });
   });
 
 
   unittest.group("obj-schema-Variant", () {
@@ skipping 412 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildDataset());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_datasetId).then(unittest.expectAsync(((api.Dataset response) {
         checkDataset(response);
       })));
     });
 
+    unittest.test("method--getIamPolicy", () {
+
+      var mock = new HttpServerMock();
+      api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
+      var arg_request = buildGetIamPolicyRequest();
+      var arg_resource = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.GetIamPolicyRequest.fromJson(json);
+        checkGetIamPolicyRequest(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 + 3), unittest.equals("v1/"));
+        pathOffset += 3;
+        // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildPolicy());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.getIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
+        checkPolicy(response);
+      })));
+    });
+
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_projectId = "foo";
       var arg_pageSize = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 82 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildDataset());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.patch(arg_request, arg_datasetId, updateMask: arg_updateMask).then(unittest.expectAsync(((api.Dataset response) {
         checkDataset(response);
       })));
     });
 
+    unittest.test("method--setIamPolicy", () {
+
+      var mock = new HttpServerMock();
+      api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
+      var arg_request = buildSetIamPolicyRequest();
+      var arg_resource = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.SetIamPolicyRequest.fromJson(json);
+        checkSetIamPolicyRequest(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 + 3), unittest.equals("v1/"));
+        pathOffset += 3;
+        // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildPolicy());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.setIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
+        checkPolicy(response);
+      })));
+    });
+
+    unittest.test("method--testIamPermissions", () {
+
+      var mock = new HttpServerMock();
+      api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
+      var arg_request = buildTestIamPermissionsRequest();
+      var arg_resource = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TestIamPermissionsRequest.fromJson(json);
+        checkTestIamPermissionsRequest(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 + 3), unittest.equals("v1/"));
+        pathOffset += 3;
+        // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildTestIamPermissionsResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.testIamPermissions(arg_request, arg_resource).then(unittest.expectAsync(((api.TestIamPermissionsResponse response) {
+        checkTestIamPermissionsResponse(response);
+      })));
+    });
+
     unittest.test("method--undelete", () {
 
       var mock = new HttpServerMock();
       api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;
       var arg_request = buildUndeleteDatasetRequest();
       var arg_datasetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.UndeleteDatasetRequest.fromJson(json);
         checkUndeleteDatasetRequest(obj);
 
@@ skipping 1503 matching lines @@
       res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantSetsResponse response) {
         checkSearchVariantSetsResponse(response);
       })));
     });
 
   });
 
 
 }