Api-roll 39: 2016-07-18

generated/googleapis/test/androidenterprise/v1_test.dart

 library googleapis.androidenterprise.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);
 }
 
-buildUnnamed395() {
+core.int buildCounterAdministrator = 0;
+buildAdministrator() {
+  var o = new api.Administrator();
+  buildCounterAdministrator++;
+  if (buildCounterAdministrator < 3) {
+    o.email = "foo";
+  }
+  buildCounterAdministrator--;
+  return o;
+}
+
+checkAdministrator(api.Administrator o) {
+  buildCounterAdministrator++;
+  if (buildCounterAdministrator < 3) {
+    unittest.expect(o.email, unittest.equals('foo'));
+  }
+  buildCounterAdministrator--;
+}
+
+buildUnnamed2226() {
   var o = new core.List<api.AppRestrictionsSchemaRestriction>();
   o.add(buildAppRestrictionsSchemaRestriction());
   o.add(buildAppRestrictionsSchemaRestriction());
   return o;
 }
 
-checkUnnamed395(core.List<api.AppRestrictionsSchemaRestriction> o) {
+checkUnnamed2226(core.List<api.AppRestrictionsSchemaRestriction> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAppRestrictionsSchemaRestriction(o[0]);
   checkAppRestrictionsSchemaRestriction(o[1]);
 }
 
 core.int buildCounterAppRestrictionsSchema = 0;
 buildAppRestrictionsSchema() {
   var o = new api.AppRestrictionsSchema();
   buildCounterAppRestrictionsSchema++;
   if (buildCounterAppRestrictionsSchema < 3) {
     o.kind = "foo";
-    o.restrictions = buildUnnamed395();
+    o.restrictions = buildUnnamed2226();
   }
   buildCounterAppRestrictionsSchema--;
   return o;
 }
 
 checkAppRestrictionsSchema(api.AppRestrictionsSchema o) {
   buildCounterAppRestrictionsSchema++;
   if (buildCounterAppRestrictionsSchema < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed395(o.restrictions);
+    checkUnnamed2226(o.restrictions);
   }
   buildCounterAppRestrictionsSchema--;
 }
 
-buildUnnamed396() {
+core.int buildCounterAppRestrictionsSchemaChangeEvent = 0;
+buildAppRestrictionsSchemaChangeEvent() {
+  var o = new api.AppRestrictionsSchemaChangeEvent();
+  buildCounterAppRestrictionsSchemaChangeEvent++;
+  if (buildCounterAppRestrictionsSchemaChangeEvent < 3) {
+    o.productId = "foo";
+  }
+  buildCounterAppRestrictionsSchemaChangeEvent--;
+  return o;
+}
+
+checkAppRestrictionsSchemaChangeEvent(api.AppRestrictionsSchemaChangeEvent o) {
+  buildCounterAppRestrictionsSchemaChangeEvent++;
+  if (buildCounterAppRestrictionsSchemaChangeEvent < 3) {
+    unittest.expect(o.productId, unittest.equals('foo'));
+  }
+  buildCounterAppRestrictionsSchemaChangeEvent--;
+}
+
+buildUnnamed2227() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed396(core.List<core.String> o) {
+checkUnnamed2227(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'));
 }
 
-buildUnnamed397() {
+buildUnnamed2228() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed397(core.List<core.String> o) {
+checkUnnamed2228(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 buildCounterAppRestrictionsSchemaRestriction = 0;
 buildAppRestrictionsSchemaRestriction() {
   var o = new api.AppRestrictionsSchemaRestriction();
   buildCounterAppRestrictionsSchemaRestriction++;
   if (buildCounterAppRestrictionsSchemaRestriction < 3) {
     o.defaultValue = buildAppRestrictionsSchemaRestrictionRestrictionValue();
     o.description = "foo";
-    o.entry = buildUnnamed396();
-    o.entryValue = buildUnnamed397();
+    o.entry = buildUnnamed2227();
+    o.entryValue = buildUnnamed2228();
     o.key = "foo";
     o.restrictionType = "foo";
     o.title = "foo";
   }
   buildCounterAppRestrictionsSchemaRestriction--;
   return o;
 }
 
 checkAppRestrictionsSchemaRestriction(api.AppRestrictionsSchemaRestriction o) {
   buildCounterAppRestrictionsSchemaRestriction++;
   if (buildCounterAppRestrictionsSchemaRestriction < 3) {
     checkAppRestrictionsSchemaRestrictionRestrictionValue(o.defaultValue);
     unittest.expect(o.description, unittest.equals('foo'));
-    checkUnnamed396(o.entry);
-    checkUnnamed397(o.entryValue);
+    checkUnnamed2227(o.entry);
+    checkUnnamed2228(o.entryValue);
     unittest.expect(o.key, unittest.equals('foo'));
     unittest.expect(o.restrictionType, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterAppRestrictionsSchemaRestriction--;
 }
 
-buildUnnamed398() {
+buildUnnamed2229() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed398(core.List<core.String> o) {
+checkUnnamed2229(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 buildCounterAppRestrictionsSchemaRestrictionRestrictionValue = 0;
 buildAppRestrictionsSchemaRestrictionRestrictionValue() {
   var o = new api.AppRestrictionsSchemaRestrictionRestrictionValue();
   buildCounterAppRestrictionsSchemaRestrictionRestrictionValue++;
   if (buildCounterAppRestrictionsSchemaRestrictionRestrictionValue < 3) {
     o.type = "foo";
     o.valueBool = true;
     o.valueInteger = 42;
-    o.valueMultiselect = buildUnnamed398();
+    o.valueMultiselect = buildUnnamed2229();
     o.valueString = "foo";
   }
   buildCounterAppRestrictionsSchemaRestrictionRestrictionValue--;
   return o;
 }
 
 checkAppRestrictionsSchemaRestrictionRestrictionValue(api.AppRestrictionsSchemaRestrictionRestrictionValue o) {
   buildCounterAppRestrictionsSchemaRestrictionRestrictionValue++;
   if (buildCounterAppRestrictionsSchemaRestrictionRestrictionValue < 3) {
     unittest.expect(o.type, unittest.equals('foo'));
     unittest.expect(o.valueBool, unittest.isTrue);
     unittest.expect(o.valueInteger, unittest.equals(42));
-    checkUnnamed398(o.valueMultiselect);
+    checkUnnamed2229(o.valueMultiselect);
     unittest.expect(o.valueString, unittest.equals('foo'));
   }
   buildCounterAppRestrictionsSchemaRestrictionRestrictionValue--;
 }
 
+core.int buildCounterAppUpdateEvent = 0;
+buildAppUpdateEvent() {
+  var o = new api.AppUpdateEvent();
+  buildCounterAppUpdateEvent++;
+  if (buildCounterAppUpdateEvent < 3) {
+    o.productId = "foo";
+  }
+  buildCounterAppUpdateEvent--;
+  return o;
+}
+
+checkAppUpdateEvent(api.AppUpdateEvent o) {
+  buildCounterAppUpdateEvent++;
+  if (buildCounterAppUpdateEvent < 3) {
+    unittest.expect(o.productId, unittest.equals('foo'));
+  }
+  buildCounterAppUpdateEvent--;
+}
+
 core.int buildCounterAppVersion = 0;
 buildAppVersion() {
   var o = new api.AppVersion();
   buildCounterAppVersion++;
   if (buildCounterAppVersion < 3) {
     o.versionCode = 42;
     o.versionString = "foo";
   }
   buildCounterAppVersion--;
   return o;
@@ skipping 22 matching lines @@
 
 checkApprovalUrlInfo(api.ApprovalUrlInfo o) {
   buildCounterApprovalUrlInfo++;
   if (buildCounterApprovalUrlInfo < 3) {
     unittest.expect(o.approvalUrl, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterApprovalUrlInfo--;
 }
 
-buildUnnamed399() {
+core.int buildCounterAuthenticationToken = 0;
+buildAuthenticationToken() {
+  var o = new api.AuthenticationToken();
+  buildCounterAuthenticationToken++;
+  if (buildCounterAuthenticationToken < 3) {
+    o.kind = "foo";
+    o.token = "foo";
+  }
+  buildCounterAuthenticationToken--;
+  return o;
+}
+
+checkAuthenticationToken(api.AuthenticationToken o) {
+  buildCounterAuthenticationToken++;
+  if (buildCounterAuthenticationToken < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.token, unittest.equals('foo'));
+  }
+  buildCounterAuthenticationToken--;
+}
+
+buildUnnamed2230() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed399(core.List<core.String> o) {
+checkUnnamed2230(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 buildCounterCollection = 0;
 buildCollection() {
   var o = new api.Collection();
   buildCounterCollection++;
   if (buildCounterCollection < 3) {
     o.collectionId = "foo";
     o.kind = "foo";
     o.name = "foo";
-    o.productId = buildUnnamed399();
+    o.productId = buildUnnamed2230();
     o.visibility = "foo";
   }
   buildCounterCollection--;
   return o;
 }
 
 checkCollection(api.Collection o) {
   buildCounterCollection++;
   if (buildCounterCollection < 3) {
     unittest.expect(o.collectionId, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed399(o.productId);
+    checkUnnamed2230(o.productId);
     unittest.expect(o.visibility, unittest.equals('foo'));
   }
   buildCounterCollection--;
 }
 
-buildUnnamed400() {
+buildUnnamed2231() {
   var o = new core.List<api.User>();
   o.add(buildUser());
   o.add(buildUser());
   return o;
 }
 
-checkUnnamed400(core.List<api.User> o) {
+checkUnnamed2231(core.List<api.User> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUser(o[0]);
   checkUser(o[1]);
 }
 
 core.int buildCounterCollectionViewersListResponse = 0;
 buildCollectionViewersListResponse() {
   var o = new api.CollectionViewersListResponse();
   buildCounterCollectionViewersListResponse++;
   if (buildCounterCollectionViewersListResponse < 3) {
     o.kind = "foo";
-    o.user = buildUnnamed400();
+    o.user = buildUnnamed2231();
   }
   buildCounterCollectionViewersListResponse--;
   return o;
 }
 
 checkCollectionViewersListResponse(api.CollectionViewersListResponse o) {
   buildCounterCollectionViewersListResponse++;
   if (buildCounterCollectionViewersListResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed400(o.user);
+    checkUnnamed2231(o.user);
   }
   buildCounterCollectionViewersListResponse--;
 }
 
-buildUnnamed401() {
+buildUnnamed2232() {
   var o = new core.List<api.Collection>();
   o.add(buildCollection());
   o.add(buildCollection());
   return o;
 }
 
-checkUnnamed401(core.List<api.Collection> o) {
+checkUnnamed2232(core.List<api.Collection> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCollection(o[0]);
   checkCollection(o[1]);
 }
 
 core.int buildCounterCollectionsListResponse = 0;
 buildCollectionsListResponse() {
   var o = new api.CollectionsListResponse();
   buildCounterCollectionsListResponse++;
   if (buildCounterCollectionsListResponse < 3) {
-    o.collection = buildUnnamed401();
+    o.collection = buildUnnamed2232();
     o.kind = "foo";
   }
   buildCounterCollectionsListResponse--;
   return o;
 }
 
 checkCollectionsListResponse(api.CollectionsListResponse o) {
   buildCounterCollectionsListResponse++;
   if (buildCounterCollectionsListResponse < 3) {
-    checkUnnamed401(o.collection);
+    checkUnnamed2232(o.collection);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterCollectionsListResponse--;
 }
 
 core.int buildCounterDevice = 0;
 buildDevice() {
   var o = new api.Device();
   buildCounterDevice++;
   if (buildCounterDevice < 3) {
@@ skipping 29 matching lines @@
 
 checkDeviceState(api.DeviceState o) {
   buildCounterDeviceState++;
   if (buildCounterDeviceState < 3) {
     unittest.expect(o.accountState, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterDeviceState--;
 }
 
-buildUnnamed402() {
+buildUnnamed2233() {
   var o = new core.List<api.Device>();
   o.add(buildDevice());
   o.add(buildDevice());
   return o;
 }
 
-checkUnnamed402(core.List<api.Device> o) {
+checkUnnamed2233(core.List<api.Device> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDevice(o[0]);
   checkDevice(o[1]);
 }
 
 core.int buildCounterDevicesListResponse = 0;
 buildDevicesListResponse() {
   var o = new api.DevicesListResponse();
   buildCounterDevicesListResponse++;
   if (buildCounterDevicesListResponse < 3) {
-    o.device = buildUnnamed402();
+    o.device = buildUnnamed2233();
     o.kind = "foo";
   }
   buildCounterDevicesListResponse--;
   return o;
 }
 
 checkDevicesListResponse(api.DevicesListResponse o) {
   buildCounterDevicesListResponse++;
   if (buildCounterDevicesListResponse < 3) {
-    checkUnnamed402(o.device);
+    checkUnnamed2233(o.device);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterDevicesListResponse--;
 }
 
+buildUnnamed2234() {
+  var o = new core.List<api.Administrator>();
+  o.add(buildAdministrator());
+  o.add(buildAdministrator());
+  return o;
+}
+
+checkUnnamed2234(core.List<api.Administrator> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAdministrator(o[0]);
+  checkAdministrator(o[1]);
+}
+
 core.int buildCounterEnterprise = 0;
 buildEnterprise() {
   var o = new api.Enterprise();
   buildCounterEnterprise++;
   if (buildCounterEnterprise < 3) {
+    o.administrator = buildUnnamed2234();
     o.id = "foo";
     o.kind = "foo";
     o.name = "foo";
     o.primaryDomain = "foo";
   }
   buildCounterEnterprise--;
   return o;
 }
 
 checkEnterprise(api.Enterprise o) {
   buildCounterEnterprise++;
   if (buildCounterEnterprise < 3) {
+    checkUnnamed2234(o.administrator);
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.primaryDomain, unittest.equals('foo'));
   }
   buildCounterEnterprise--;
 }
 
 core.int buildCounterEnterpriseAccount = 0;
 buildEnterpriseAccount() {
   var o = new api.EnterpriseAccount();
   buildCounterEnterpriseAccount++;
   if (buildCounterEnterpriseAccount < 3) {
     o.accountEmail = "foo";
     o.kind = "foo";
   }
   buildCounterEnterpriseAccount--;
   return o;
 }
 
 checkEnterpriseAccount(api.EnterpriseAccount o) {
   buildCounterEnterpriseAccount++;
   if (buildCounterEnterpriseAccount < 3) {
     unittest.expect(o.accountEmail, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterEnterpriseAccount--;
 }
 
-buildUnnamed403() {
+buildUnnamed2235() {
   var o = new core.List<api.Enterprise>();
   o.add(buildEnterprise());
   o.add(buildEnterprise());
   return o;
 }
 
-checkUnnamed403(core.List<api.Enterprise> o) {
+checkUnnamed2235(core.List<api.Enterprise> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkEnterprise(o[0]);
   checkEnterprise(o[1]);
 }
 
 core.int buildCounterEnterprisesListResponse = 0;
 buildEnterprisesListResponse() {
   var o = new api.EnterprisesListResponse();
   buildCounterEnterprisesListResponse++;
   if (buildCounterEnterprisesListResponse < 3) {
-    o.enterprise = buildUnnamed403();
+    o.enterprise = buildUnnamed2235();
     o.kind = "foo";
   }
   buildCounterEnterprisesListResponse--;
   return o;
 }
 
 checkEnterprisesListResponse(api.EnterprisesListResponse o) {
   buildCounterEnterprisesListResponse++;
   if (buildCounterEnterprisesListResponse < 3) {
-    checkUnnamed403(o.enterprise);
+    checkUnnamed2235(o.enterprise);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterEnterprisesListResponse--;
 }
 
 core.int buildCounterEnterprisesSendTestPushNotificationResponse = 0;
 buildEnterprisesSendTestPushNotificationResponse() {
   var o = new api.EnterprisesSendTestPushNotificationResponse();
   buildCounterEnterprisesSendTestPushNotificationResponse++;
   if (buildCounterEnterprisesSendTestPushNotificationResponse < 3) {
@@ skipping 29 matching lines @@
 checkEntitlement(api.Entitlement o) {
   buildCounterEntitlement++;
   if (buildCounterEntitlement < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.productId, unittest.equals('foo'));
     unittest.expect(o.reason, unittest.equals('foo'));
   }
   buildCounterEntitlement--;
 }
 
-buildUnnamed404() {
+buildUnnamed2236() {
   var o = new core.List<api.Entitlement>();
   o.add(buildEntitlement());
   o.add(buildEntitlement());
   return o;
 }
 
-checkUnnamed404(core.List<api.Entitlement> o) {
+checkUnnamed2236(core.List<api.Entitlement> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkEntitlement(o[0]);
   checkEntitlement(o[1]);
 }
 
 core.int buildCounterEntitlementsListResponse = 0;
 buildEntitlementsListResponse() {
   var o = new api.EntitlementsListResponse();
   buildCounterEntitlementsListResponse++;
   if (buildCounterEntitlementsListResponse < 3) {
-    o.entitlement = buildUnnamed404();
+    o.entitlement = buildUnnamed2236();
     o.kind = "foo";
   }
   buildCounterEntitlementsListResponse--;
   return o;
 }
 
 checkEntitlementsListResponse(api.EntitlementsListResponse o) {
   buildCounterEntitlementsListResponse++;
   if (buildCounterEntitlementsListResponse < 3) {
-    checkUnnamed404(o.entitlement);
+    checkUnnamed2236(o.entitlement);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterEntitlementsListResponse--;
 }
 
 core.int buildCounterGroupLicense = 0;
 buildGroupLicense() {
   var o = new api.GroupLicense();
   buildCounterGroupLicense++;
   if (buildCounterGroupLicense < 3) {
@@ skipping 14 matching lines @@
     unittest.expect(o.acquisitionKind, unittest.equals('foo'));
     unittest.expect(o.approval, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.numProvisioned, unittest.equals(42));
     unittest.expect(o.numPurchased, unittest.equals(42));
     unittest.expect(o.productId, unittest.equals('foo'));
   }
   buildCounterGroupLicense--;
 }
 
-buildUnnamed405() {
+buildUnnamed2237() {
   var o = new core.List<api.User>();
   o.add(buildUser());
   o.add(buildUser());
   return o;
 }
 
-checkUnnamed405(core.List<api.User> o) {
+checkUnnamed2237(core.List<api.User> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUser(o[0]);
   checkUser(o[1]);
 }
 
 core.int buildCounterGroupLicenseUsersListResponse = 0;
 buildGroupLicenseUsersListResponse() {
   var o = new api.GroupLicenseUsersListResponse();
   buildCounterGroupLicenseUsersListResponse++;
   if (buildCounterGroupLicenseUsersListResponse < 3) {
     o.kind = "foo";
-    o.user = buildUnnamed405();
+    o.user = buildUnnamed2237();
   }
   buildCounterGroupLicenseUsersListResponse--;
   return o;
 }
 
 checkGroupLicenseUsersListResponse(api.GroupLicenseUsersListResponse o) {
   buildCounterGroupLicenseUsersListResponse++;
   if (buildCounterGroupLicenseUsersListResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed405(o.user);
+    checkUnnamed2237(o.user);
   }
   buildCounterGroupLicenseUsersListResponse--;
 }
 
-buildUnnamed406() {
+buildUnnamed2238() {
   var o = new core.List<api.GroupLicense>();
   o.add(buildGroupLicense());
   o.add(buildGroupLicense());
   return o;
 }
 
-checkUnnamed406(core.List<api.GroupLicense> o) {
+checkUnnamed2238(core.List<api.GroupLicense> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkGroupLicense(o[0]);
   checkGroupLicense(o[1]);
 }
 
 core.int buildCounterGroupLicensesListResponse = 0;
 buildGroupLicensesListResponse() {
   var o = new api.GroupLicensesListResponse();
   buildCounterGroupLicensesListResponse++;
   if (buildCounterGroupLicensesListResponse < 3) {
-    o.groupLicense = buildUnnamed406();
+    o.groupLicense = buildUnnamed2238();
     o.kind = "foo";
   }
   buildCounterGroupLicensesListResponse--;
   return o;
 }
 
 checkGroupLicensesListResponse(api.GroupLicensesListResponse o) {
   buildCounterGroupLicensesListResponse++;
   if (buildCounterGroupLicensesListResponse < 3) {
-    checkUnnamed406(o.groupLicense);
+    checkUnnamed2238(o.groupLicense);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterGroupLicensesListResponse--;
 }
 
 core.int buildCounterInstall = 0;
 buildInstall() {
   var o = new api.Install();
   buildCounterInstall++;
   if (buildCounterInstall < 3) {
@@ skipping 10 matching lines @@
   buildCounterInstall++;
   if (buildCounterInstall < 3) {
     unittest.expect(o.installState, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.productId, unittest.equals('foo'));
     unittest.expect(o.versionCode, unittest.equals(42));
   }
   buildCounterInstall--;
 }
 
-buildUnnamed407() {
+core.int buildCounterInstallFailureEvent = 0;
+buildInstallFailureEvent() {
+  var o = new api.InstallFailureEvent();
+  buildCounterInstallFailureEvent++;
+  if (buildCounterInstallFailureEvent < 3) {
+    o.deviceId = "foo";
+    o.failureDetails = "foo";
+    o.failureReason = "foo";
+    o.productId = "foo";
+    o.userId = "foo";
+  }
+  buildCounterInstallFailureEvent--;
+  return o;
+}
+
+checkInstallFailureEvent(api.InstallFailureEvent o) {
+  buildCounterInstallFailureEvent++;
+  if (buildCounterInstallFailureEvent < 3) {
+    unittest.expect(o.deviceId, unittest.equals('foo'));
+    unittest.expect(o.failureDetails, unittest.equals('foo'));
+    unittest.expect(o.failureReason, unittest.equals('foo'));
+    unittest.expect(o.productId, unittest.equals('foo'));
+    unittest.expect(o.userId, unittest.equals('foo'));
+  }
+  buildCounterInstallFailureEvent--;
+}
+
+buildUnnamed2239() {
   var o = new core.List<api.Install>();
   o.add(buildInstall());
   o.add(buildInstall());
   return o;
 }
 
-checkUnnamed407(core.List<api.Install> o) {
+checkUnnamed2239(core.List<api.Install> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkInstall(o[0]);
   checkInstall(o[1]);
 }
 
 core.int buildCounterInstallsListResponse = 0;
 buildInstallsListResponse() {
   var o = new api.InstallsListResponse();
   buildCounterInstallsListResponse++;
   if (buildCounterInstallsListResponse < 3) {
-    o.install = buildUnnamed407();
+    o.install = buildUnnamed2239();
     o.kind = "foo";
   }
   buildCounterInstallsListResponse--;
   return o;
 }
 
 checkInstallsListResponse(api.InstallsListResponse o) {
   buildCounterInstallsListResponse++;
   if (buildCounterInstallsListResponse < 3) {
-    checkUnnamed407(o.install);
+    checkUnnamed2239(o.install);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterInstallsListResponse--;
 }
 
 core.int buildCounterLocalizedText = 0;
 buildLocalizedText() {
   var o = new api.LocalizedText();
   buildCounterLocalizedText++;
   if (buildCounterLocalizedText < 3) {
     o.locale = "foo";
     o.text = "foo";
   }
   buildCounterLocalizedText--;
   return o;
 }
 
 checkLocalizedText(api.LocalizedText o) {
   buildCounterLocalizedText++;
   if (buildCounterLocalizedText < 3) {
     unittest.expect(o.locale, unittest.equals('foo'));
     unittest.expect(o.text, unittest.equals('foo'));
   }
   buildCounterLocalizedText--;
 }
 
+buildUnnamed2240() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed2240(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'));
+}
+
+buildUnnamed2241() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed2241(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 buildCounterNewPermissionsEvent = 0;
+buildNewPermissionsEvent() {
+  var o = new api.NewPermissionsEvent();
+  buildCounterNewPermissionsEvent++;
+  if (buildCounterNewPermissionsEvent < 3) {
+    o.approvedPermissions = buildUnnamed2240();
+    o.productId = "foo";
+    o.requestedPermissions = buildUnnamed2241();
+  }
+  buildCounterNewPermissionsEvent--;
+  return o;
+}
+
+checkNewPermissionsEvent(api.NewPermissionsEvent o) {
+  buildCounterNewPermissionsEvent++;
+  if (buildCounterNewPermissionsEvent < 3) {
+    checkUnnamed2240(o.approvedPermissions);
+    unittest.expect(o.productId, unittest.equals('foo'));
+    checkUnnamed2241(o.requestedPermissions);
+  }
+  buildCounterNewPermissionsEvent--;
+}
+
+core.int buildCounterNotification = 0;
+buildNotification() {
+  var o = new api.Notification();
+  buildCounterNotification++;
+  if (buildCounterNotification < 3) {
+    o.appRestrictionsSchemaChangeEvent = buildAppRestrictionsSchemaChangeEvent();
+    o.appUpdateEvent = buildAppUpdateEvent();
+    o.enterpriseId = "foo";
+    o.installFailureEvent = buildInstallFailureEvent();
+    o.newPermissionsEvent = buildNewPermissionsEvent();
+    o.productApprovalEvent = buildProductApprovalEvent();
+    o.productAvailabilityChangeEvent = buildProductAvailabilityChangeEvent();
+    o.timestampMillis = "foo";
+  }
+  buildCounterNotification--;
+  return o;
+}
+
+checkNotification(api.Notification o) {
+  buildCounterNotification++;
+  if (buildCounterNotification < 3) {
+    checkAppRestrictionsSchemaChangeEvent(o.appRestrictionsSchemaChangeEvent);
+    checkAppUpdateEvent(o.appUpdateEvent);
+    unittest.expect(o.enterpriseId, unittest.equals('foo'));
+    checkInstallFailureEvent(o.installFailureEvent);
+    checkNewPermissionsEvent(o.newPermissionsEvent);
+    checkProductApprovalEvent(o.productApprovalEvent);
+    checkProductAvailabilityChangeEvent(o.productAvailabilityChangeEvent);
+    unittest.expect(o.timestampMillis, unittest.equals('foo'));
+  }
+  buildCounterNotification--;
+}
+
+buildUnnamed2242() {
+  var o = new core.List<api.Notification>();
+  o.add(buildNotification());
+  o.add(buildNotification());
+  return o;
+}
+
+checkUnnamed2242(core.List<api.Notification> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkNotification(o[0]);
+  checkNotification(o[1]);
+}
+
+core.int buildCounterNotificationSet = 0;
+buildNotificationSet() {
+  var o = new api.NotificationSet();
+  buildCounterNotificationSet++;
+  if (buildCounterNotificationSet < 3) {
+    o.kind = "foo";
+    o.notification = buildUnnamed2242();
+    o.notificationSetId = "foo";
+  }
+  buildCounterNotificationSet--;
+  return o;
+}
+
+checkNotificationSet(api.NotificationSet o) {
+  buildCounterNotificationSet++;
+  if (buildCounterNotificationSet < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed2242(o.notification);
+    unittest.expect(o.notificationSetId, unittest.equals('foo'));
+  }
+  buildCounterNotificationSet--;
+}
+
 core.int buildCounterPageInfo = 0;
 buildPageInfo() {
   var o = new api.PageInfo();
   buildCounterPageInfo++;
   if (buildCounterPageInfo < 3) {
     o.resultPerPage = 42;
     o.startIndex = 42;
     o.totalResults = 42;
   }
   buildCounterPageInfo--;
@@ skipping 28 matching lines @@
   buildCounterPermission++;
   if (buildCounterPermission < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.permissionId, unittest.equals('foo'));
   }
   buildCounterPermission--;
 }
 
-buildUnnamed408() {
+buildUnnamed2243() {
   var o = new core.List<api.AppVersion>();
   o.add(buildAppVersion());
   o.add(buildAppVersion());
   return o;
 }
 
-checkUnnamed408(core.List<api.AppVersion> o) {
+checkUnnamed2243(core.List<api.AppVersion> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAppVersion(o[0]);
   checkAppVersion(o[1]);
 }
 
 core.int buildCounterProduct = 0;
 buildProduct() {
   var o = new api.Product();
   buildCounterProduct++;
   if (buildCounterProduct < 3) {
-    o.appVersion = buildUnnamed408();
+    o.appVersion = buildUnnamed2243();
     o.authorName = "foo";
     o.detailsUrl = "foo";
     o.distributionChannel = "foo";
     o.iconUrl = "foo";
     o.kind = "foo";
     o.productId = "foo";
     o.productPricing = "foo";
     o.requiresContainerApp = true;
     o.smallIconUrl = "foo";
     o.title = "foo";
     o.workDetailsUrl = "foo";
   }
   buildCounterProduct--;
   return o;
 }
 
 checkProduct(api.Product o) {
   buildCounterProduct++;
   if (buildCounterProduct < 3) {
-    checkUnnamed408(o.appVersion);
+    checkUnnamed2243(o.appVersion);
     unittest.expect(o.authorName, unittest.equals('foo'));
     unittest.expect(o.detailsUrl, unittest.equals('foo'));
     unittest.expect(o.distributionChannel, unittest.equals('foo'));
     unittest.expect(o.iconUrl, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.productId, unittest.equals('foo'));
     unittest.expect(o.productPricing, unittest.equals('foo'));
     unittest.expect(o.requiresContainerApp, unittest.isTrue);
     unittest.expect(o.smallIconUrl, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.workDetailsUrl, unittest.equals('foo'));
   }
   buildCounterProduct--;
 }
 
+core.int buildCounterProductApprovalEvent = 0;
+buildProductApprovalEvent() {
+  var o = new api.ProductApprovalEvent();
+  buildCounterProductApprovalEvent++;
+  if (buildCounterProductApprovalEvent < 3) {
+    o.approved = "foo";
+    o.productId = "foo";
+  }
+  buildCounterProductApprovalEvent--;
+  return o;
+}
+
+checkProductApprovalEvent(api.ProductApprovalEvent o) {
+  buildCounterProductApprovalEvent++;
+  if (buildCounterProductApprovalEvent < 3) {
+    unittest.expect(o.approved, unittest.equals('foo'));
+    unittest.expect(o.productId, unittest.equals('foo'));
+  }
+  buildCounterProductApprovalEvent--;
+}
+
+core.int buildCounterProductAvailabilityChangeEvent = 0;
+buildProductAvailabilityChangeEvent() {
+  var o = new api.ProductAvailabilityChangeEvent();
+  buildCounterProductAvailabilityChangeEvent++;
+  if (buildCounterProductAvailabilityChangeEvent < 3) {
+    o.availabilityStatus = "foo";
+    o.productId = "foo";
+  }
+  buildCounterProductAvailabilityChangeEvent--;
+  return o;
+}
+
+checkProductAvailabilityChangeEvent(api.ProductAvailabilityChangeEvent o) {
+  buildCounterProductAvailabilityChangeEvent++;
+  if (buildCounterProductAvailabilityChangeEvent < 3) {
+    unittest.expect(o.availabilityStatus, unittest.equals('foo'));
+    unittest.expect(o.productId, unittest.equals('foo'));
+  }
+  buildCounterProductAvailabilityChangeEvent--;
+}
+
 core.int buildCounterProductPermission = 0;
 buildProductPermission() {
   var o = new api.ProductPermission();
   buildCounterProductPermission++;
   if (buildCounterProductPermission < 3) {
     o.permissionId = "foo";
     o.state = "foo";
   }
   buildCounterProductPermission--;
   return o;
 }
 
 checkProductPermission(api.ProductPermission o) {
   buildCounterProductPermission++;
   if (buildCounterProductPermission < 3) {
     unittest.expect(o.permissionId, unittest.equals('foo'));
     unittest.expect(o.state, unittest.equals('foo'));
   }
   buildCounterProductPermission--;
 }
 
-buildUnnamed409() {
+buildUnnamed2244() {
   var o = new core.List<api.ProductPermission>();
   o.add(buildProductPermission());
   o.add(buildProductPermission());
   return o;
 }
 
-checkUnnamed409(core.List<api.ProductPermission> o) {
+checkUnnamed2244(core.List<api.ProductPermission> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkProductPermission(o[0]);
   checkProductPermission(o[1]);
 }
 
 core.int buildCounterProductPermissions = 0;
 buildProductPermissions() {
   var o = new api.ProductPermissions();
   buildCounterProductPermissions++;
   if (buildCounterProductPermissions < 3) {
     o.kind = "foo";
-    o.permission = buildUnnamed409();
+    o.permission = buildUnnamed2244();
     o.productId = "foo";
   }
   buildCounterProductPermissions--;
   return o;
 }
 
 checkProductPermissions(api.ProductPermissions o) {
   buildCounterProductPermissions++;
   if (buildCounterProductPermissions < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed409(o.permission);
+    checkUnnamed2244(o.permission);
     unittest.expect(o.productId, unittest.equals('foo'));
   }
   buildCounterProductPermissions--;
 }
 
-buildUnnamed410() {
+buildUnnamed2245() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed410(core.List<core.String> o) {
+checkUnnamed2245(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 buildCounterProductSet = 0;
 buildProductSet() {
   var o = new api.ProductSet();
   buildCounterProductSet++;
   if (buildCounterProductSet < 3) {
     o.kind = "foo";
-    o.productId = buildUnnamed410();
+    o.productId = buildUnnamed2245();
   }
   buildCounterProductSet--;
   return o;
 }
 
 checkProductSet(api.ProductSet o) {
   buildCounterProductSet++;
   if (buildCounterProductSet < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed410(o.productId);
+    checkUnnamed2245(o.productId);
   }
   buildCounterProductSet--;
 }
 
 core.int buildCounterProductsApproveRequest = 0;
 buildProductsApproveRequest() {
   var o = new api.ProductsApproveRequest();
   buildCounterProductsApproveRequest++;
   if (buildCounterProductsApproveRequest < 3) {
     o.approvalUrlInfo = buildApprovalUrlInfo();
@@ skipping 22 matching lines @@
 }
 
 checkProductsGenerateApprovalUrlResponse(api.ProductsGenerateApprovalUrlResponse o) {
   buildCounterProductsGenerateApprovalUrlResponse++;
   if (buildCounterProductsGenerateApprovalUrlResponse < 3) {
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterProductsGenerateApprovalUrlResponse--;
 }
 
-buildUnnamed411() {
+buildUnnamed2246() {
   var o = new core.List<api.Product>();
   o.add(buildProduct());
   o.add(buildProduct());
   return o;
 }
 
-checkUnnamed411(core.List<api.Product> o) {
+checkUnnamed2246(core.List<api.Product> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkProduct(o[0]);
   checkProduct(o[1]);
 }
 
 core.int buildCounterProductsListResponse = 0;
 buildProductsListResponse() {
   var o = new api.ProductsListResponse();
   buildCounterProductsListResponse++;
   if (buildCounterProductsListResponse < 3) {
     o.kind = "foo";
     o.pageInfo = buildPageInfo();
-    o.product = buildUnnamed411();
+    o.product = buildUnnamed2246();
     o.tokenPagination = buildTokenPagination();
   }
   buildCounterProductsListResponse--;
   return o;
 }
 
 checkProductsListResponse(api.ProductsListResponse o) {
   buildCounterProductsListResponse++;
   if (buildCounterProductsListResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
-    checkUnnamed411(o.product);
+    checkUnnamed2246(o.product);
     checkTokenPagination(o.tokenPagination);
   }
   buildCounterProductsListResponse--;
 }
 
-buildUnnamed412() {
+core.int buildCounterServiceAccount = 0;
+buildServiceAccount() {
+  var o = new api.ServiceAccount();
+  buildCounterServiceAccount++;
+  if (buildCounterServiceAccount < 3) {
+    o.key = buildServiceAccountKey();
+    o.kind = "foo";
+    o.name = "foo";
+  }
+  buildCounterServiceAccount--;
+  return o;
+}
+
+checkServiceAccount(api.ServiceAccount o) {
+  buildCounterServiceAccount++;
+  if (buildCounterServiceAccount < 3) {
+    checkServiceAccountKey(o.key);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+  }
+  buildCounterServiceAccount--;
+}
+
+core.int buildCounterServiceAccountKey = 0;
+buildServiceAccountKey() {
+  var o = new api.ServiceAccountKey();
+  buildCounterServiceAccountKey++;
+  if (buildCounterServiceAccountKey < 3) {
+    o.data = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.type = "foo";
+  }
+  buildCounterServiceAccountKey--;
+  return o;
+}
+
+checkServiceAccountKey(api.ServiceAccountKey o) {
+  buildCounterServiceAccountKey++;
+  if (buildCounterServiceAccountKey < 3) {
+    unittest.expect(o.data, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.type, unittest.equals('foo'));
+  }
+  buildCounterServiceAccountKey--;
+}
+
+buildUnnamed2247() {
+  var o = new core.List<api.ServiceAccountKey>();
+  o.add(buildServiceAccountKey());
+  o.add(buildServiceAccountKey());
+  return o;
+}
+
+checkUnnamed2247(core.List<api.ServiceAccountKey> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkServiceAccountKey(o[0]);
+  checkServiceAccountKey(o[1]);
+}
+
+core.int buildCounterServiceAccountKeysListResponse = 0;
+buildServiceAccountKeysListResponse() {
+  var o = new api.ServiceAccountKeysListResponse();
+  buildCounterServiceAccountKeysListResponse++;
+  if (buildCounterServiceAccountKeysListResponse < 3) {
+    o.serviceAccountKey = buildUnnamed2247();
+  }
+  buildCounterServiceAccountKeysListResponse--;
+  return o;
+}
+
+checkServiceAccountKeysListResponse(api.ServiceAccountKeysListResponse o) {
+  buildCounterServiceAccountKeysListResponse++;
+  if (buildCounterServiceAccountKeysListResponse < 3) {
+    checkUnnamed2247(o.serviceAccountKey);
+  }
+  buildCounterServiceAccountKeysListResponse--;
+}
+
+core.int buildCounterSignupInfo = 0;
+buildSignupInfo() {
+  var o = new api.SignupInfo();
+  buildCounterSignupInfo++;
+  if (buildCounterSignupInfo < 3) {
+    o.completionToken = "foo";
+    o.kind = "foo";
+    o.url = "foo";
+  }
+  buildCounterSignupInfo--;
+  return o;
+}
+
+checkSignupInfo(api.SignupInfo o) {
+  buildCounterSignupInfo++;
+  if (buildCounterSignupInfo < 3) {
+    unittest.expect(o.completionToken, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.url, unittest.equals('foo'));
+  }
+  buildCounterSignupInfo--;
+}
+
+buildUnnamed2248() {
   var o = new core.List<api.LocalizedText>();
   o.add(buildLocalizedText());
   o.add(buildLocalizedText());
   return o;
 }
 
-checkUnnamed412(core.List<api.LocalizedText> o) {
+checkUnnamed2248(core.List<api.LocalizedText> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLocalizedText(o[0]);
   checkLocalizedText(o[1]);
 }
 
-buildUnnamed413() {
+buildUnnamed2249() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed413(core.List<core.String> o) {
+checkUnnamed2249(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 buildCounterStoreCluster = 0;
 buildStoreCluster() {
   var o = new api.StoreCluster();
   buildCounterStoreCluster++;
   if (buildCounterStoreCluster < 3) {
     o.id = "foo";
     o.kind = "foo";
-    o.name = buildUnnamed412();
+    o.name = buildUnnamed2248();
     o.orderInPage = "foo";
-    o.productId = buildUnnamed413();
+    o.productId = buildUnnamed2249();
   }
   buildCounterStoreCluster--;
   return o;
 }
 
 checkStoreCluster(api.StoreCluster o) {
   buildCounterStoreCluster++;
   if (buildCounterStoreCluster < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed412(o.name);
+    checkUnnamed2248(o.name);
     unittest.expect(o.orderInPage, unittest.equals('foo'));
-    checkUnnamed413(o.productId);
+    checkUnnamed2249(o.productId);
   }
   buildCounterStoreCluster--;
 }
 
 core.int buildCounterStoreLayout = 0;
 buildStoreLayout() {
   var o = new api.StoreLayout();
   buildCounterStoreLayout++;
   if (buildCounterStoreLayout < 3) {
     o.homepageId = "foo";
     o.kind = "foo";
   }
   buildCounterStoreLayout--;
   return o;
 }
 
 checkStoreLayout(api.StoreLayout o) {
   buildCounterStoreLayout++;
   if (buildCounterStoreLayout < 3) {
     unittest.expect(o.homepageId, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterStoreLayout--;
 }
 
-buildUnnamed414() {
+buildUnnamed2250() {
   var o = new core.List<api.StoreCluster>();
   o.add(buildStoreCluster());
   o.add(buildStoreCluster());
   return o;
 }
 
-checkUnnamed414(core.List<api.StoreCluster> o) {
+checkUnnamed2250(core.List<api.StoreCluster> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStoreCluster(o[0]);
   checkStoreCluster(o[1]);
 }
 
 core.int buildCounterStoreLayoutClustersListResponse = 0;
 buildStoreLayoutClustersListResponse() {
   var o = new api.StoreLayoutClustersListResponse();
   buildCounterStoreLayoutClustersListResponse++;
   if (buildCounterStoreLayoutClustersListResponse < 3) {
-    o.cluster = buildUnnamed414();
+    o.cluster = buildUnnamed2250();
     o.kind = "foo";
   }
   buildCounterStoreLayoutClustersListResponse--;
   return o;
 }
 
 checkStoreLayoutClustersListResponse(api.StoreLayoutClustersListResponse o) {
   buildCounterStoreLayoutClustersListResponse++;
   if (buildCounterStoreLayoutClustersListResponse < 3) {
-    checkUnnamed414(o.cluster);
+    checkUnnamed2250(o.cluster);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterStoreLayoutClustersListResponse--;
 }
 
-buildUnnamed415() {
+buildUnnamed2251() {
   var o = new core.List<api.StorePage>();
   o.add(buildStorePage());
   o.add(buildStorePage());
   return o;
 }
 
-checkUnnamed415(core.List<api.StorePage> o) {
+checkUnnamed2251(core.List<api.StorePage> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStorePage(o[0]);
   checkStorePage(o[1]);
 }
 
 core.int buildCounterStoreLayoutPagesListResponse = 0;
 buildStoreLayoutPagesListResponse() {
   var o = new api.StoreLayoutPagesListResponse();
   buildCounterStoreLayoutPagesListResponse++;
   if (buildCounterStoreLayoutPagesListResponse < 3) {
     o.kind = "foo";
-    o.page = buildUnnamed415();
+    o.page = buildUnnamed2251();
   }
   buildCounterStoreLayoutPagesListResponse--;
   return o;
 }
 
 checkStoreLayoutPagesListResponse(api.StoreLayoutPagesListResponse o) {
   buildCounterStoreLayoutPagesListResponse++;
   if (buildCounterStoreLayoutPagesListResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed415(o.page);
+    checkUnnamed2251(o.page);
   }
   buildCounterStoreLayoutPagesListResponse--;
 }
 
-buildUnnamed416() {
+buildUnnamed2252() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed416(core.List<core.String> o) {
+checkUnnamed2252(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'));
 }
 
-buildUnnamed417() {
+buildUnnamed2253() {
   var o = new core.List<api.LocalizedText>();
   o.add(buildLocalizedText());
   o.add(buildLocalizedText());
   return o;
 }
 
-checkUnnamed417(core.List<api.LocalizedText> o) {
+checkUnnamed2253(core.List<api.LocalizedText> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLocalizedText(o[0]);
   checkLocalizedText(o[1]);
 }
 
 core.int buildCounterStorePage = 0;
 buildStorePage() {
   var o = new api.StorePage();
   buildCounterStorePage++;
   if (buildCounterStorePage < 3) {
     o.id = "foo";
     o.kind = "foo";
-    o.link = buildUnnamed416();
-    o.name = buildUnnamed417();
+    o.link = buildUnnamed2252();
+    o.name = buildUnnamed2253();
   }
   buildCounterStorePage--;
   return o;
 }
 
 checkStorePage(api.StorePage o) {
   buildCounterStorePage++;
   if (buildCounterStorePage < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed416(o.link);
-    checkUnnamed417(o.name);
+    checkUnnamed2252(o.link);
+    checkUnnamed2253(o.name);
   }
   buildCounterStorePage--;
 }
 
 core.int buildCounterTokenPagination = 0;
 buildTokenPagination() {
   var o = new api.TokenPagination();
   buildCounterTokenPagination++;
   if (buildCounterTokenPagination < 3) {
     o.nextPageToken = "foo";
@@ skipping 10 matching lines @@
     unittest.expect(o.previousPageToken, unittest.equals('foo'));
   }
   buildCounterTokenPagination--;
 }
 
 core.int buildCounterUser = 0;
 buildUser() {
   var o = new api.User();
   buildCounterUser++;
   if (buildCounterUser < 3) {
+    o.accountIdentifier = "foo";
+    o.accountType = "foo";
+    o.displayName = "foo";
     o.id = "foo";
     o.kind = "foo";
+    o.managementType = "foo";
     o.primaryEmail = "foo";
   }
   buildCounterUser--;
   return o;
 }
 
 checkUser(api.User o) {
   buildCounterUser++;
   if (buildCounterUser < 3) {
+    unittest.expect(o.accountIdentifier, unittest.equals('foo'));
+    unittest.expect(o.accountType, unittest.equals('foo'));
+    unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.managementType, unittest.equals('foo'));
     unittest.expect(o.primaryEmail, unittest.equals('foo'));
   }
   buildCounterUser--;
 }
 
 core.int buildCounterUserToken = 0;
 buildUserToken() {
   var o = new api.UserToken();
   buildCounterUserToken++;
   if (buildCounterUserToken < 3) {
     o.kind = "foo";
     o.token = "foo";
     o.userId = "foo";
   }
   buildCounterUserToken--;
   return o;
 }
 
 checkUserToken(api.UserToken o) {
   buildCounterUserToken++;
   if (buildCounterUserToken < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.token, unittest.equals('foo'));
     unittest.expect(o.userId, unittest.equals('foo'));
   }
   buildCounterUserToken--;
 }
 
-buildUnnamed418() {
+buildUnnamed2254() {
   var o = new core.List<api.User>();
   o.add(buildUser());
   o.add(buildUser());
   return o;
 }
 
-checkUnnamed418(core.List<api.User> o) {
+checkUnnamed2254(core.List<api.User> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUser(o[0]);
   checkUser(o[1]);
 }
 
 core.int buildCounterUsersListResponse = 0;
 buildUsersListResponse() {
   var o = new api.UsersListResponse();
   buildCounterUsersListResponse++;
   if (buildCounterUsersListResponse < 3) {
     o.kind = "foo";
-    o.user = buildUnnamed418();
+    o.user = buildUnnamed2254();
   }
   buildCounterUsersListResponse--;
   return o;
 }
 
 checkUsersListResponse(api.UsersListResponse o) {
   buildCounterUsersListResponse++;
   if (buildCounterUsersListResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed418(o.user);
+    checkUnnamed2254(o.user);
   }
   buildCounterUsersListResponse--;
 }
 
 
 main() {
+  unittest.group("obj-schema-Administrator", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAdministrator();
+      var od = new api.Administrator.fromJson(o.toJson());
+      checkAdministrator(od);
+    });
+  });
+
+
   unittest.group("obj-schema-AppRestrictionsSchema", () {
     unittest.test("to-json--from-json", () {
       var o = buildAppRestrictionsSchema();
       var od = new api.AppRestrictionsSchema.fromJson(o.toJson());
       checkAppRestrictionsSchema(od);
     });
   });
 
 
+  unittest.group("obj-schema-AppRestrictionsSchemaChangeEvent", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAppRestrictionsSchemaChangeEvent();
+      var od = new api.AppRestrictionsSchemaChangeEvent.fromJson(o.toJson());
+      checkAppRestrictionsSchemaChangeEvent(od);
+    });
+  });
+
+
   unittest.group("obj-schema-AppRestrictionsSchemaRestriction", () {
     unittest.test("to-json--from-json", () {
       var o = buildAppRestrictionsSchemaRestriction();
       var od = new api.AppRestrictionsSchemaRestriction.fromJson(o.toJson());
       checkAppRestrictionsSchemaRestriction(od);
     });
   });
 
 
   unittest.group("obj-schema-AppRestrictionsSchemaRestrictionRestrictionValue", () {
     unittest.test("to-json--from-json", () {
       var o = buildAppRestrictionsSchemaRestrictionRestrictionValue();
       var od = new api.AppRestrictionsSchemaRestrictionRestrictionValue.fromJson(o.toJson());
       checkAppRestrictionsSchemaRestrictionRestrictionValue(od);
     });
   });
 
 
+  unittest.group("obj-schema-AppUpdateEvent", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAppUpdateEvent();
+      var od = new api.AppUpdateEvent.fromJson(o.toJson());
+      checkAppUpdateEvent(od);
+    });
+  });
+
+
   unittest.group("obj-schema-AppVersion", () {
     unittest.test("to-json--from-json", () {
       var o = buildAppVersion();
       var od = new api.AppVersion.fromJson(o.toJson());
       checkAppVersion(od);
     });
   });
 
 
   unittest.group("obj-schema-ApprovalUrlInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildApprovalUrlInfo();
       var od = new api.ApprovalUrlInfo.fromJson(o.toJson());
       checkApprovalUrlInfo(od);
     });
   });
 
 
+  unittest.group("obj-schema-AuthenticationToken", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAuthenticationToken();
+      var od = new api.AuthenticationToken.fromJson(o.toJson());
+      checkAuthenticationToken(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Collection", () {
     unittest.test("to-json--from-json", () {
       var o = buildCollection();
       var od = new api.Collection.fromJson(o.toJson());
       checkCollection(od);
     });
   });
 
 
   unittest.group("obj-schema-CollectionViewersListResponse", () {
@@ skipping 124 matching lines @@
 
   unittest.group("obj-schema-Install", () {
     unittest.test("to-json--from-json", () {
       var o = buildInstall();
       var od = new api.Install.fromJson(o.toJson());
       checkInstall(od);
     });
   });
 
 
+  unittest.group("obj-schema-InstallFailureEvent", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstallFailureEvent();
+      var od = new api.InstallFailureEvent.fromJson(o.toJson());
+      checkInstallFailureEvent(od);
+    });
+  });
+
+
   unittest.group("obj-schema-InstallsListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildInstallsListResponse();
       var od = new api.InstallsListResponse.fromJson(o.toJson());
       checkInstallsListResponse(od);
     });
   });
 
 
   unittest.group("obj-schema-LocalizedText", () {
     unittest.test("to-json--from-json", () {
       var o = buildLocalizedText();
       var od = new api.LocalizedText.fromJson(o.toJson());
       checkLocalizedText(od);
     });
   });
 
 
+  unittest.group("obj-schema-NewPermissionsEvent", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildNewPermissionsEvent();
+      var od = new api.NewPermissionsEvent.fromJson(o.toJson());
+      checkNewPermissionsEvent(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Notification", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildNotification();
+      var od = new api.Notification.fromJson(o.toJson());
+      checkNotification(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-NotificationSet", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildNotificationSet();
+      var od = new api.NotificationSet.fromJson(o.toJson());
+      checkNotificationSet(od);
+    });
+  });
+
+
   unittest.group("obj-schema-PageInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildPageInfo();
       var od = new api.PageInfo.fromJson(o.toJson());
       checkPageInfo(od);
     });
   });
 
 
   unittest.group("obj-schema-Permission", () {
     unittest.test("to-json--from-json", () {
       var o = buildPermission();
       var od = new api.Permission.fromJson(o.toJson());
       checkPermission(od);
     });
   });
 
 
   unittest.group("obj-schema-Product", () {
     unittest.test("to-json--from-json", () {
       var o = buildProduct();
       var od = new api.Product.fromJson(o.toJson());
       checkProduct(od);
     });
   });
 
 
+  unittest.group("obj-schema-ProductApprovalEvent", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildProductApprovalEvent();
+      var od = new api.ProductApprovalEvent.fromJson(o.toJson());
+      checkProductApprovalEvent(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ProductAvailabilityChangeEvent", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildProductAvailabilityChangeEvent();
+      var od = new api.ProductAvailabilityChangeEvent.fromJson(o.toJson());
+      checkProductAvailabilityChangeEvent(od);
+    });
+  });
+
+
   unittest.group("obj-schema-ProductPermission", () {
     unittest.test("to-json--from-json", () {
       var o = buildProductPermission();
       var od = new api.ProductPermission.fromJson(o.toJson());
       checkProductPermission(od);
     });
   });
 
 
   unittest.group("obj-schema-ProductPermissions", () {
@@ skipping 34 matching lines @@
 
   unittest.group("obj-schema-ProductsListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildProductsListResponse();
       var od = new api.ProductsListResponse.fromJson(o.toJson());
       checkProductsListResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-ServiceAccount", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildServiceAccount();
+      var od = new api.ServiceAccount.fromJson(o.toJson());
+      checkServiceAccount(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ServiceAccountKey", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildServiceAccountKey();
+      var od = new api.ServiceAccountKey.fromJson(o.toJson());
+      checkServiceAccountKey(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ServiceAccountKeysListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildServiceAccountKeysListResponse();
+      var od = new api.ServiceAccountKeysListResponse.fromJson(o.toJson());
+      checkServiceAccountKeysListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-SignupInfo", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSignupInfo();
+      var od = new api.SignupInfo.fromJson(o.toJson());
+      checkSignupInfo(od);
+    });
+  });
+
+
   unittest.group("obj-schema-StoreCluster", () {
     unittest.test("to-json--from-json", () {
       var o = buildStoreCluster();
       var od = new api.StoreCluster.fromJson(o.toJson());
       checkStoreCluster(od);
     });
   });
 
 
   unittest.group("obj-schema-StoreLayout", () {
@@ skipping 1013 matching lines @@
       }), true);
       res.setState(arg_request, arg_enterpriseId, arg_userId, arg_deviceId).then(unittest.expectAsync(((api.DeviceState response) {
         checkDeviceState(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-EnterprisesResourceApi", () {
-    unittest.test("method--delete", () {
+    unittest.test("method--acknowledgeNotificationSet", () {
 
       var mock = new HttpServerMock();
       api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
-      var arg_enterpriseId = "foo";
+      var arg_notificationSetId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
         pathOffset += 21;
-        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
-        pathOffset += 12;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 38), unittest.equals("enterprises/acknowledgeNotificationSet"));
+        pathOffset += 38;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
+        unittest.expect(queryMap["notificationSetId"].first, unittest.equals(arg_notificationSetId));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
+      res.acknowledgeNotificationSet(notificationSetId: arg_notificationSetId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--completeSignup", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_completionToken = "foo";
+      var arg_enterpriseToken = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.equals("enterprises/completeSignup"));
+        pathOffset += 26;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["completionToken"].first, unittest.equals(arg_completionToken));
+        unittest.expect(queryMap["enterpriseToken"].first, unittest.equals(arg_enterpriseToken));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEnterprise());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.completeSignup(completionToken: arg_completionToken, enterpriseToken: arg_enterpriseToken).then(unittest.expectAsync(((api.Enterprise response) {
+        checkEnterprise(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
       res.delete(arg_enterpriseId).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--enroll", () {
 
       var mock = new HttpServerMock();
       api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
       var arg_request = buildEnterprise();
       var arg_token = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 34 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildEnterprise());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.enroll(arg_request, arg_token).then(unittest.expectAsync(((api.Enterprise response) {
         checkEnterprise(response);
       })));
     });
 
+    unittest.test("method--generateSignupUrl", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_callbackUrl = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("enterprises/signupUrl"));
+        pathOffset += 21;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["callbackUrl"].first, unittest.equals(arg_callbackUrl));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildSignupInfo());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.generateSignupUrl(callbackUrl: arg_callbackUrl).then(unittest.expectAsync(((api.SignupInfo response) {
+        checkSignupInfo(response);
+      })));
+    });
+
     unittest.test("method--get", () {
 
       var mock = new HttpServerMock();
       api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
       var arg_enterpriseId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 29 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildEnterprise());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_enterpriseId).then(unittest.expectAsync(((api.Enterprise response) {
         checkEnterprise(response);
       })));
     });
 
+    unittest.test("method--getServiceAccount", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_enterpriseId = "foo";
+      var arg_keyType = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/serviceAccount", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/serviceAccount"));
+        pathOffset += 15;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["keyType"].first, unittest.equals(arg_keyType));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildServiceAccount());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.getServiceAccount(arg_enterpriseId, keyType: arg_keyType).then(unittest.expectAsync(((api.ServiceAccount response) {
+        checkServiceAccount(response);
+      })));
+    });
+
     unittest.test("method--getStoreLayout", () {
 
       var mock = new HttpServerMock();
       api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
       var arg_enterpriseId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 131 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildEnterprisesListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_domain).then(unittest.expectAsync(((api.EnterprisesListResponse response) {
         checkEnterprisesListResponse(response);
       })));
     });
 
+    unittest.test("method--pullNotificationSet", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_requestMode = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 31), unittest.equals("enterprises/pullNotificationSet"));
+        pathOffset += 31;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["requestMode"].first, unittest.equals(arg_requestMode));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildNotificationSet());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.pullNotificationSet(requestMode: arg_requestMode).then(unittest.expectAsync(((api.NotificationSet response) {
+        checkNotificationSet(response);
+      })));
+    });
+
     unittest.test("method--sendTestPushNotification", () {
 
       var mock = new HttpServerMock();
       api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
       var arg_enterpriseId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 1514 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildProductsListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_enterpriseId, approved: arg_approved, language: arg_language, maxResults: arg_maxResults, query: arg_query, token: arg_token).then(unittest.expectAsync(((api.ProductsListResponse response) {
         checkProductsListResponse(response);
       })));
     });
 
-    unittest.test("method--updatePermissions", () {
+    unittest.test("method--unapprove", () {
 
       var mock = new HttpServerMock();
       api.ProductsResourceApi res = new api.AndroidenterpriseApi(mock).products;
-      var arg_request = buildProductPermissions();
       var arg_enterpriseId = "foo";
       var arg_productId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
-        var obj = new api.ProductPermissions.fromJson(json);
-        checkProductPermissions(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 + 21), unittest.equals("androidenterprise/v1/"));
         pathOffset += 21;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
         pathOffset += 12;
         index = path.indexOf("/products/", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
         unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/products/"));
         pathOffset += 10;
-        index = path.indexOf("/permissions", pathOffset);
+        index = path.indexOf("/unapprove", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_productId"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/permissions"));
-        pathOffset += 12;
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/unapprove"));
+        pathOffset += 10;
 
         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(buildProductPermissions());
+        var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.updatePermissions(arg_request, arg_enterpriseId, arg_productId).then(unittest.expectAsync(((api.ProductPermissions response) {
-        checkProductPermissions(response);
-      })));
+      res.unapprove(arg_enterpriseId, arg_productId).then(unittest.expectAsync((_) {}));
     });
 
-  });
-
-
-  unittest.group("resource-StorelayoutclustersResourceApi", () {
-    unittest.test("method--delete", () {
+    unittest.test("method--updatePermissions", () {
 
       var mock = new HttpServerMock();
-      api.StorelayoutclustersResourceApi res = new api.AndroidenterpriseApi(mock).storelayoutclusters;
+      api.ProductsResourceApi res = new api.AndroidenterpriseApi(mock).products;
+      var arg_request = buildProductPermissions();
       var arg_enterpriseId = "foo";
-      var arg_pageId = "foo";
-      var arg_clusterId = "foo";
+      var arg_productId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ProductPermissions.fromJson(json);
+        checkProductPermissions(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 + 21), unittest.equals("androidenterprise/v1/"));
         pathOffset += 21;
         unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
         pathOffset += 12;
+        index = path.indexOf("/products/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/products/"));
+        pathOffset += 10;
+        index = path.indexOf("/permissions", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_productId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/permissions"));
+        pathOffset += 12;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildProductPermissions());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.updatePermissions(arg_request, arg_enterpriseId, arg_productId).then(unittest.expectAsync(((api.ProductPermissions response) {
+        checkProductPermissions(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ServiceaccountkeysResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.ServiceaccountkeysResourceApi res = new api.AndroidenterpriseApi(mock).serviceaccountkeys;
+      var arg_enterpriseId = "foo";
+      var arg_keyId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/serviceAccountKeys/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("/serviceAccountKeys/"));
+        pathOffset += 20;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_keyId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId, arg_keyId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new HttpServerMock();
+      api.ServiceaccountkeysResourceApi res = new api.AndroidenterpriseApi(mock).serviceaccountkeys;
+      var arg_request = buildServiceAccountKey();
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ServiceAccountKey.fromJson(json);
+        checkServiceAccountKey(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 + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/serviceAccountKeys", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/serviceAccountKeys"));
+        pathOffset += 19;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildServiceAccountKey());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.insert(arg_request, arg_enterpriseId).then(unittest.expectAsync(((api.ServiceAccountKey response) {
+        checkServiceAccountKey(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.ServiceaccountkeysResourceApi res = new api.AndroidenterpriseApi(mock).serviceaccountkeys;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/serviceAccountKeys", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/serviceAccountKeys"));
+        pathOffset += 19;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildServiceAccountKeysListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId).then(unittest.expectAsync(((api.ServiceAccountKeysListResponse response) {
+        checkServiceAccountKeysListResponse(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-StorelayoutclustersResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.StorelayoutclustersResourceApi res = new api.AndroidenterpriseApi(mock).storelayoutclusters;
+      var arg_enterpriseId = "foo";
+      var arg_pageId = "foo";
+      var arg_clusterId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
         index = path.indexOf("/storeLayout/pages/", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
         unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/storeLayout/pages/"));
         pathOffset += 19;
         index = path.indexOf("/clusters/", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
@@ skipping 706 matching lines @@
       }), true);
       res.update(arg_request, arg_enterpriseId, arg_pageId).then(unittest.expectAsync(((api.StorePage response) {
         checkStorePage(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-UsersResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId, arg_userId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--generateAuthenticationToken", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/authenticationToken", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("/authenticationToken"));
+        pathOffset += 20;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildAuthenticationToken());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.generateAuthenticationToken(arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.AuthenticationToken response) {
+        checkAuthenticationToken(response);
+      })));
+    });
+
     unittest.test("method--generateToken", () {
 
       var mock = new HttpServerMock();
       api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
       var arg_enterpriseId = "foo";
       var arg_userId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 159 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildProductSet());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getAvailableProductSet(arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.ProductSet response) {
         checkProductSet(response);
       })));
     });
 
+    unittest.test("method--insert", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_request = buildUser();
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.User.fromJson(json);
+        checkUser(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 + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/users"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.insert(arg_request, arg_enterpriseId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
       var arg_enterpriseId = "foo";
       var arg_email = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 35 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildUsersListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_enterpriseId, arg_email).then(unittest.expectAsync(((api.UsersListResponse response) {
         checkUsersListResponse(response);
       })));
     });
 
+    unittest.test("method--patch", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_request = buildUser();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.User.fromJson(json);
+        checkUser(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 + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        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(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
     unittest.test("method--revokeToken", () {
 
       var mock = new HttpServerMock();
       api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
       var arg_enterpriseId = "foo";
       var arg_userId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 104 matching lines @@
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildProductSet());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.setAvailableProductSet(arg_request, arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.ProductSet response) {
         checkProductSet(response);
       })));
     });
 
+    unittest.test("method--update", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_request = buildUser();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.User.fromJson(json);
+        checkUser(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 + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        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(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
   });
 
 
 }