Api-roll 21: 2015-08-04

generated/googleapis/test/deploymentmanager/v2_test.dart

-library googleapis_beta.deploymentmanager.v2beta1.test;
+library googleapis.deploymentmanager.v2.test;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart' as http_testing;
 import 'package:unittest/unittest.dart' as unittest;
 
-import 'package:googleapis_beta/deploymentmanager/v2beta1.dart' as api;
+import 'package:googleapis/deploymentmanager/v2.dart' as api;
 
 class HttpServerMock extends http.BaseClient {
   core.Function _callback;
   core.bool _expectJson;
 
   void register(core.Function callback, core.bool expectJson) {
     _callback = callback;
     _expectJson = expectJson;
   }
 
@@ skipping 21 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);
 }
 
+core.int buildCounterConfigFile = 0;
+buildConfigFile() {
+  var o = new api.ConfigFile();
+  buildCounterConfigFile++;
+  if (buildCounterConfigFile < 3) {
+    o.content = "foo";
+  }
+  buildCounterConfigFile--;
+  return o;
+}
+
+checkConfigFile(api.ConfigFile o) {
+  buildCounterConfigFile++;
+  if (buildCounterConfigFile < 3) {
+    unittest.expect(o.content, unittest.equals('foo'));
+  }
+  buildCounterConfigFile--;
+}
+
 core.int buildCounterDeployment = 0;
 buildDeployment() {
   var o = new api.Deployment();
   buildCounterDeployment++;
   if (buildCounterDeployment < 3) {
     o.description = "foo";
+    o.fingerprint = "foo";
     o.id = "foo";
+    o.insertTime = "foo";
     o.manifest = "foo";
     o.name = "foo";
-    o.targetConfig = "foo";
+    o.operation = buildOperation();
+    o.target = buildTargetConfiguration();
+    o.update = buildDeploymentUpdate();
   }
   buildCounterDeployment--;
   return o;
 }
 
 checkDeployment(api.Deployment o) {
   buildCounterDeployment++;
   if (buildCounterDeployment < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.insertTime, unittest.equals('foo'));
     unittest.expect(o.manifest, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.targetConfig, unittest.equals('foo'));
+    checkOperation(o.operation);
+    checkTargetConfiguration(o.target);
+    checkDeploymentUpdate(o.update);
   }
   buildCounterDeployment--;
 }
 
-buildUnnamed1656() {
+core.int buildCounterDeploymentUpdate = 0;
+buildDeploymentUpdate() {
+  var o = new api.DeploymentUpdate();
+  buildCounterDeploymentUpdate++;
+  if (buildCounterDeploymentUpdate < 3) {
+    o.manifest = "foo";
+  }
+  buildCounterDeploymentUpdate--;
+  return o;
+}
+
+checkDeploymentUpdate(api.DeploymentUpdate o) {
+  buildCounterDeploymentUpdate++;
+  if (buildCounterDeploymentUpdate < 3) {
+    unittest.expect(o.manifest, unittest.equals('foo'));
+  }
+  buildCounterDeploymentUpdate--;
+}
+
+core.int buildCounterDeploymentsCancelPreviewRequest = 0;
+buildDeploymentsCancelPreviewRequest() {
+  var o = new api.DeploymentsCancelPreviewRequest();
+  buildCounterDeploymentsCancelPreviewRequest++;
+  if (buildCounterDeploymentsCancelPreviewRequest < 3) {
+    o.fingerprint = "foo";
+  }
+  buildCounterDeploymentsCancelPreviewRequest--;
+  return o;
+}
+
+checkDeploymentsCancelPreviewRequest(api.DeploymentsCancelPreviewRequest o) {
+  buildCounterDeploymentsCancelPreviewRequest++;
+  if (buildCounterDeploymentsCancelPreviewRequest < 3) {
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
+  }
+  buildCounterDeploymentsCancelPreviewRequest--;
+}
+
+buildUnnamed738() {
   var o = new core.List<api.Deployment>();
   o.add(buildDeployment());
   o.add(buildDeployment());
   return o;
 }
 
-checkUnnamed1656(core.List<api.Deployment> o) {
+checkUnnamed738(core.List<api.Deployment> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDeployment(o[0]);
   checkDeployment(o[1]);
 }
 
 core.int buildCounterDeploymentsListResponse = 0;
 buildDeploymentsListResponse() {
   var o = new api.DeploymentsListResponse();
   buildCounterDeploymentsListResponse++;
   if (buildCounterDeploymentsListResponse < 3) {
-    o.deployments = buildUnnamed1656();
+    o.deployments = buildUnnamed738();
     o.nextPageToken = "foo";
   }
   buildCounterDeploymentsListResponse--;
   return o;
 }
 
 checkDeploymentsListResponse(api.DeploymentsListResponse o) {
   buildCounterDeploymentsListResponse++;
   if (buildCounterDeploymentsListResponse < 3) {
-    checkUnnamed1656(o.deployments);
+    checkUnnamed738(o.deployments);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterDeploymentsListResponse--;
 }
 
+core.int buildCounterDeploymentsStopRequest = 0;
+buildDeploymentsStopRequest() {
+  var o = new api.DeploymentsStopRequest();
+  buildCounterDeploymentsStopRequest++;
+  if (buildCounterDeploymentsStopRequest < 3) {
+    o.fingerprint = "foo";
+  }
+  buildCounterDeploymentsStopRequest--;
+  return o;
+}
+
+checkDeploymentsStopRequest(api.DeploymentsStopRequest o) {
+  buildCounterDeploymentsStopRequest++;
+  if (buildCounterDeploymentsStopRequest < 3) {
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
+  }
+  buildCounterDeploymentsStopRequest--;
+}
+
+core.int buildCounterImportFile = 0;
+buildImportFile() {
+  var o = new api.ImportFile();
+  buildCounterImportFile++;
+  if (buildCounterImportFile < 3) {
+    o.content = "foo";
+    o.name = "foo";
+  }
+  buildCounterImportFile--;
+  return o;
+}
+
+checkImportFile(api.ImportFile o) {
+  buildCounterImportFile++;
+  if (buildCounterImportFile < 3) {
+    unittest.expect(o.content, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+  }
+  buildCounterImportFile--;
+}
+
+buildUnnamed739() {
+  var o = new core.List<api.ImportFile>();
+  o.add(buildImportFile());
+  o.add(buildImportFile());
+  return o;
+}
+
+checkUnnamed739(core.List<api.ImportFile> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkImportFile(o[0]);
+  checkImportFile(o[1]);
+}
+
 core.int buildCounterManifest = 0;
 buildManifest() {
   var o = new api.Manifest();
   buildCounterManifest++;
   if (buildCounterManifest < 3) {
-    o.config = "foo";
-    o.evaluatedConfig = "foo";
+    o.config = buildConfigFile();
+    o.expandedConfig = "foo";
     o.id = "foo";
+    o.imports = buildUnnamed739();
+    o.insertTime = "foo";
+    o.layout = "foo";
     o.name = "foo";
     o.selfLink = "foo";
   }
   buildCounterManifest--;
   return o;
 }
 
 checkManifest(api.Manifest o) {
   buildCounterManifest++;
   if (buildCounterManifest < 3) {
-    unittest.expect(o.config, unittest.equals('foo'));
-    unittest.expect(o.evaluatedConfig, unittest.equals('foo'));
+    checkConfigFile(o.config);
+    unittest.expect(o.expandedConfig, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed739(o.imports);
+    unittest.expect(o.insertTime, unittest.equals('foo'));
+    unittest.expect(o.layout, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
   }
   buildCounterManifest--;
 }
 
-buildUnnamed1657() {
+buildUnnamed740() {
   var o = new core.List<api.Manifest>();
   o.add(buildManifest());
   o.add(buildManifest());
   return o;
 }
 
-checkUnnamed1657(core.List<api.Manifest> o) {
+checkUnnamed740(core.List<api.Manifest> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkManifest(o[0]);
   checkManifest(o[1]);
 }
 
 core.int buildCounterManifestsListResponse = 0;
 buildManifestsListResponse() {
   var o = new api.ManifestsListResponse();
   buildCounterManifestsListResponse++;
   if (buildCounterManifestsListResponse < 3) {
-    o.manifests = buildUnnamed1657();
+    o.manifests = buildUnnamed740();
     o.nextPageToken = "foo";
   }
   buildCounterManifestsListResponse--;
   return o;
 }
 
 checkManifestsListResponse(api.ManifestsListResponse o) {
   buildCounterManifestsListResponse++;
   if (buildCounterManifestsListResponse < 3) {
-    checkUnnamed1657(o.manifests);
+    checkUnnamed740(o.manifests);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterManifestsListResponse--;
 }
 
 core.int buildCounterOperationErrorErrors = 0;
 buildOperationErrorErrors() {
   var o = new api.OperationErrorErrors();
   buildCounterOperationErrorErrors++;
   if (buildCounterOperationErrorErrors < 3) {
     o.code = "foo";
     o.location = "foo";
     o.message = "foo";
   }
   buildCounterOperationErrorErrors--;
   return o;
 }
 
 checkOperationErrorErrors(api.OperationErrorErrors o) {
   buildCounterOperationErrorErrors++;
   if (buildCounterOperationErrorErrors < 3) {
     unittest.expect(o.code, unittest.equals('foo'));
     unittest.expect(o.location, unittest.equals('foo'));
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterOperationErrorErrors--;
 }
 
-buildUnnamed1658() {
+buildUnnamed741() {
   var o = new core.List<api.OperationErrorErrors>();
   o.add(buildOperationErrorErrors());
   o.add(buildOperationErrorErrors());
   return o;
 }
 
-checkUnnamed1658(core.List<api.OperationErrorErrors> o) {
+checkUnnamed741(core.List<api.OperationErrorErrors> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationErrorErrors(o[0]);
   checkOperationErrorErrors(o[1]);
 }
 
 core.int buildCounterOperationError = 0;
 buildOperationError() {
   var o = new api.OperationError();
   buildCounterOperationError++;
   if (buildCounterOperationError < 3) {
-    o.errors = buildUnnamed1658();
+    o.errors = buildUnnamed741();
   }
   buildCounterOperationError--;
   return o;
 }
 
 checkOperationError(api.OperationError o) {
   buildCounterOperationError++;
   if (buildCounterOperationError < 3) {
-    checkUnnamed1658(o.errors);
+    checkUnnamed741(o.errors);
   }
   buildCounterOperationError--;
 }
 
 core.int buildCounterOperationWarningsData = 0;
 buildOperationWarningsData() {
   var o = new api.OperationWarningsData();
   buildCounterOperationWarningsData++;
   if (buildCounterOperationWarningsData < 3) {
     o.key = "foo";
     o.value = "foo";
   }
   buildCounterOperationWarningsData--;
   return o;
 }
 
 checkOperationWarningsData(api.OperationWarningsData o) {
   buildCounterOperationWarningsData++;
   if (buildCounterOperationWarningsData < 3) {
     unittest.expect(o.key, unittest.equals('foo'));
     unittest.expect(o.value, unittest.equals('foo'));
   }
   buildCounterOperationWarningsData--;
 }
 
-buildUnnamed1659() {
+buildUnnamed742() {
   var o = new core.List<api.OperationWarningsData>();
   o.add(buildOperationWarningsData());
   o.add(buildOperationWarningsData());
   return o;
 }
 
-checkUnnamed1659(core.List<api.OperationWarningsData> o) {
+checkUnnamed742(core.List<api.OperationWarningsData> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationWarningsData(o[0]);
   checkOperationWarningsData(o[1]);
 }
 
 core.int buildCounterOperationWarnings = 0;
 buildOperationWarnings() {
   var o = new api.OperationWarnings();
   buildCounterOperationWarnings++;
   if (buildCounterOperationWarnings < 3) {
-    o.code = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-    o.data = buildUnnamed1659();
+    o.code = "foo";
+    o.data = buildUnnamed742();
     o.message = "foo";
   }
   buildCounterOperationWarnings--;
   return o;
 }
 
 checkOperationWarnings(api.OperationWarnings o) {
   buildCounterOperationWarnings++;
   if (buildCounterOperationWarnings < 3) {
-    var casted1 = (o.code) as core.Map; unittest.expect(casted1, unittest.hasLength(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], unittest.equals('foo')); 
-    checkUnnamed1659(o.data);
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed742(o.data);
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterOperationWarnings--;
 }
 
-buildUnnamed1660() {
+buildUnnamed743() {
   var o = new core.List<api.OperationWarnings>();
   o.add(buildOperationWarnings());
   o.add(buildOperationWarnings());
   return o;
 }
 
-checkUnnamed1660(core.List<api.OperationWarnings> o) {
+checkUnnamed743(core.List<api.OperationWarnings> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationWarnings(o[0]);
   checkOperationWarnings(o[1]);
 }
 
 core.int buildCounterOperation = 0;
 buildOperation() {
   var o = new api.Operation();
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
+    o.clientOperationId = "foo";
     o.creationTimestamp = "foo";
     o.endTime = "foo";
     o.error = buildOperationError();
     o.httpErrorMessage = "foo";
     o.httpErrorStatusCode = 42;
     o.id = "foo";
     o.insertTime = "foo";
+    o.kind = "foo";
     o.name = "foo";
     o.operationType = "foo";
     o.progress = 42;
+    o.region = "foo";
     o.selfLink = "foo";
     o.startTime = "foo";
     o.status = "foo";
     o.statusMessage = "foo";
     o.targetId = "foo";
     o.targetLink = "foo";
     o.user = "foo";
-    o.warnings = buildUnnamed1660();
+    o.warnings = buildUnnamed743();
+    o.zone = "foo";
   }
   buildCounterOperation--;
   return o;
 }
 
 checkOperation(api.Operation o) {
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
+    unittest.expect(o.clientOperationId, unittest.equals('foo'));
     unittest.expect(o.creationTimestamp, unittest.equals('foo'));
     unittest.expect(o.endTime, unittest.equals('foo'));
     checkOperationError(o.error);
     unittest.expect(o.httpErrorMessage, unittest.equals('foo'));
     unittest.expect(o.httpErrorStatusCode, unittest.equals(42));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.insertTime, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.operationType, unittest.equals('foo'));
     unittest.expect(o.progress, unittest.equals(42));
+    unittest.expect(o.region, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.startTime, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.statusMessage, unittest.equals('foo'));
     unittest.expect(o.targetId, unittest.equals('foo'));
     unittest.expect(o.targetLink, unittest.equals('foo'));
     unittest.expect(o.user, unittest.equals('foo'));
-    checkUnnamed1660(o.warnings);
+    checkUnnamed743(o.warnings);
+    unittest.expect(o.zone, unittest.equals('foo'));
   }
   buildCounterOperation--;
 }
 
-buildUnnamed1661() {
+buildUnnamed744() {
   var o = new core.List<api.Operation>();
   o.add(buildOperation());
   o.add(buildOperation());
   return o;
 }
 
-checkUnnamed1661(core.List<api.Operation> o) {
+checkUnnamed744(core.List<api.Operation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperation(o[0]);
   checkOperation(o[1]);
 }
 
 core.int buildCounterOperationsListResponse = 0;
 buildOperationsListResponse() {
   var o = new api.OperationsListResponse();
   buildCounterOperationsListResponse++;
   if (buildCounterOperationsListResponse < 3) {
     o.nextPageToken = "foo";
-    o.operations = buildUnnamed1661();
+    o.operations = buildUnnamed744();
   }
   buildCounterOperationsListResponse--;
   return o;
 }
 
 checkOperationsListResponse(api.OperationsListResponse o) {
   buildCounterOperationsListResponse++;
   if (buildCounterOperationsListResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1661(o.operations);
+    checkUnnamed744(o.operations);
   }
   buildCounterOperationsListResponse--;
 }
 
-buildUnnamed1662() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
+core.int buildCounterResourceWarningsData = 0;
+buildResourceWarningsData() {
+  var o = new api.ResourceWarningsData();
+  buildCounterResourceWarningsData++;
+  if (buildCounterResourceWarningsData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterResourceWarningsData--;
   return o;
 }
 
-checkUnnamed1662(core.List<core.String> o) {
+checkResourceWarningsData(api.ResourceWarningsData o) {
+  buildCounterResourceWarningsData++;
+  if (buildCounterResourceWarningsData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterResourceWarningsData--;
+}
+
+buildUnnamed745() {
+  var o = new core.List<api.ResourceWarningsData>();
+  o.add(buildResourceWarningsData());
+  o.add(buildResourceWarningsData());
+  return o;
+}
+
+checkUnnamed745(core.List<api.ResourceWarningsData> o) {
   unittest.expect(o, unittest.hasLength(2));
-  unittest.expect(o[0], unittest.equals('foo'));
-  unittest.expect(o[1], unittest.equals('foo'));
+  checkResourceWarningsData(o[0]);
+  checkResourceWarningsData(o[1]);
+}
+
+core.int buildCounterResourceWarnings = 0;
+buildResourceWarnings() {
+  var o = new api.ResourceWarnings();
+  buildCounterResourceWarnings++;
+  if (buildCounterResourceWarnings < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed745();
+    o.message = "foo";
+  }
+  buildCounterResourceWarnings--;
+  return o;
+}
+
+checkResourceWarnings(api.ResourceWarnings o) {
+  buildCounterResourceWarnings++;
+  if (buildCounterResourceWarnings < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed745(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterResourceWarnings--;
+}
+
+buildUnnamed746() {
+  var o = new core.List<api.ResourceWarnings>();
+  o.add(buildResourceWarnings());
+  o.add(buildResourceWarnings());
+  return o;
+}
+
+checkUnnamed746(core.List<api.ResourceWarnings> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkResourceWarnings(o[0]);
+  checkResourceWarnings(o[1]);
 }
 
 core.int buildCounterResource = 0;
 buildResource() {
   var o = new api.Resource();
   buildCounterResource++;
   if (buildCounterResource < 3) {
-    o.errors = buildUnnamed1662();
+    o.finalProperties = "foo";
     o.id = "foo";
-    o.intent = "foo";
+    o.insertTime = "foo";
     o.manifest = "foo";
     o.name = "foo";
-    o.state = "foo";
+    o.properties = "foo";
     o.type = "foo";
+    o.update = buildResourceUpdate();
+    o.updateTime = "foo";
     o.url = "foo";
+    o.warnings = buildUnnamed746();
   }
   buildCounterResource--;
   return o;
 }
 
 checkResource(api.Resource o) {
   buildCounterResource++;
   if (buildCounterResource < 3) {
-    checkUnnamed1662(o.errors);
+    unittest.expect(o.finalProperties, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    unittest.expect(o.intent, unittest.equals('foo'));
+    unittest.expect(o.insertTime, unittest.equals('foo'));
     unittest.expect(o.manifest, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
-    unittest.expect(o.state, unittest.equals('foo'));
+    unittest.expect(o.properties, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
+    checkResourceUpdate(o.update);
+    unittest.expect(o.updateTime, unittest.equals('foo'));
     unittest.expect(o.url, unittest.equals('foo'));
+    checkUnnamed746(o.warnings);
   }
   buildCounterResource--;
 }
 
-buildUnnamed1663() {
+core.int buildCounterResourceUpdateErrorErrors = 0;
+buildResourceUpdateErrorErrors() {
+  var o = new api.ResourceUpdateErrorErrors();
+  buildCounterResourceUpdateErrorErrors++;
+  if (buildCounterResourceUpdateErrorErrors < 3) {
+    o.code = "foo";
+    o.location = "foo";
+    o.message = "foo";
+  }
+  buildCounterResourceUpdateErrorErrors--;
+  return o;
+}
+
+checkResourceUpdateErrorErrors(api.ResourceUpdateErrorErrors o) {
+  buildCounterResourceUpdateErrorErrors++;
+  if (buildCounterResourceUpdateErrorErrors < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    unittest.expect(o.location, unittest.equals('foo'));
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterResourceUpdateErrorErrors--;
+}
+
+buildUnnamed747() {
+  var o = new core.List<api.ResourceUpdateErrorErrors>();
+  o.add(buildResourceUpdateErrorErrors());
+  o.add(buildResourceUpdateErrorErrors());
+  return o;
+}
+
+checkUnnamed747(core.List<api.ResourceUpdateErrorErrors> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkResourceUpdateErrorErrors(o[0]);
+  checkResourceUpdateErrorErrors(o[1]);
+}
+
+core.int buildCounterResourceUpdateError = 0;
+buildResourceUpdateError() {
+  var o = new api.ResourceUpdateError();
+  buildCounterResourceUpdateError++;
+  if (buildCounterResourceUpdateError < 3) {
+    o.errors = buildUnnamed747();
+  }
+  buildCounterResourceUpdateError--;
+  return o;
+}
+
+checkResourceUpdateError(api.ResourceUpdateError o) {
+  buildCounterResourceUpdateError++;
+  if (buildCounterResourceUpdateError < 3) {
+    checkUnnamed747(o.errors);
+  }
+  buildCounterResourceUpdateError--;
+}
+
+core.int buildCounterResourceUpdateWarningsData = 0;
+buildResourceUpdateWarningsData() {
+  var o = new api.ResourceUpdateWarningsData();
+  buildCounterResourceUpdateWarningsData++;
+  if (buildCounterResourceUpdateWarningsData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterResourceUpdateWarningsData--;
+  return o;
+}
+
+checkResourceUpdateWarningsData(api.ResourceUpdateWarningsData o) {
+  buildCounterResourceUpdateWarningsData++;
+  if (buildCounterResourceUpdateWarningsData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterResourceUpdateWarningsData--;
+}
+
+buildUnnamed748() {
+  var o = new core.List<api.ResourceUpdateWarningsData>();
+  o.add(buildResourceUpdateWarningsData());
+  o.add(buildResourceUpdateWarningsData());
+  return o;
+}
+
+checkUnnamed748(core.List<api.ResourceUpdateWarningsData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkResourceUpdateWarningsData(o[0]);
+  checkResourceUpdateWarningsData(o[1]);
+}
+
+core.int buildCounterResourceUpdateWarnings = 0;
+buildResourceUpdateWarnings() {
+  var o = new api.ResourceUpdateWarnings();
+  buildCounterResourceUpdateWarnings++;
+  if (buildCounterResourceUpdateWarnings < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed748();
+    o.message = "foo";
+  }
+  buildCounterResourceUpdateWarnings--;
+  return o;
+}
+
+checkResourceUpdateWarnings(api.ResourceUpdateWarnings o) {
+  buildCounterResourceUpdateWarnings++;
+  if (buildCounterResourceUpdateWarnings < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed748(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterResourceUpdateWarnings--;
+}
+
+buildUnnamed749() {
+  var o = new core.List<api.ResourceUpdateWarnings>();
+  o.add(buildResourceUpdateWarnings());
+  o.add(buildResourceUpdateWarnings());
+  return o;
+}
+
+checkUnnamed749(core.List<api.ResourceUpdateWarnings> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkResourceUpdateWarnings(o[0]);
+  checkResourceUpdateWarnings(o[1]);
+}
+
+core.int buildCounterResourceUpdate = 0;
+buildResourceUpdate() {
+  var o = new api.ResourceUpdate();
+  buildCounterResourceUpdate++;
+  if (buildCounterResourceUpdate < 3) {
+    o.error = buildResourceUpdateError();
+    o.finalProperties = "foo";
+    o.intent = "foo";
+    o.manifest = "foo";
+    o.properties = "foo";
+    o.state = "foo";
+    o.warnings = buildUnnamed749();
+  }
+  buildCounterResourceUpdate--;
+  return o;
+}
+
+checkResourceUpdate(api.ResourceUpdate o) {
+  buildCounterResourceUpdate++;
+  if (buildCounterResourceUpdate < 3) {
+    checkResourceUpdateError(o.error);
+    unittest.expect(o.finalProperties, unittest.equals('foo'));
+    unittest.expect(o.intent, unittest.equals('foo'));
+    unittest.expect(o.manifest, unittest.equals('foo'));
+    unittest.expect(o.properties, unittest.equals('foo'));
+    unittest.expect(o.state, unittest.equals('foo'));
+    checkUnnamed749(o.warnings);
+  }
+  buildCounterResourceUpdate--;
+}
+
+buildUnnamed750() {
   var o = new core.List<api.Resource>();
   o.add(buildResource());
   o.add(buildResource());
   return o;
 }
 
-checkUnnamed1663(core.List<api.Resource> o) {
+checkUnnamed750(core.List<api.Resource> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkResource(o[0]);
   checkResource(o[1]);
 }
 
 core.int buildCounterResourcesListResponse = 0;
 buildResourcesListResponse() {
   var o = new api.ResourcesListResponse();
   buildCounterResourcesListResponse++;
   if (buildCounterResourcesListResponse < 3) {
     o.nextPageToken = "foo";
-    o.resources = buildUnnamed1663();
+    o.resources = buildUnnamed750();
   }
   buildCounterResourcesListResponse--;
   return o;
 }
 
 checkResourcesListResponse(api.ResourcesListResponse o) {
   buildCounterResourcesListResponse++;
   if (buildCounterResourcesListResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1663(o.resources);
+    checkUnnamed750(o.resources);
   }
   buildCounterResourcesListResponse--;
 }
 
+buildUnnamed751() {
+  var o = new core.List<api.ImportFile>();
+  o.add(buildImportFile());
+  o.add(buildImportFile());
+  return o;
+}
+
+checkUnnamed751(core.List<api.ImportFile> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkImportFile(o[0]);
+  checkImportFile(o[1]);
+}
+
+core.int buildCounterTargetConfiguration = 0;
+buildTargetConfiguration() {
+  var o = new api.TargetConfiguration();
+  buildCounterTargetConfiguration++;
+  if (buildCounterTargetConfiguration < 3) {
+    o.config = buildConfigFile();
+    o.imports = buildUnnamed751();
+  }
+  buildCounterTargetConfiguration--;
+  return o;
+}
+
+checkTargetConfiguration(api.TargetConfiguration o) {
+  buildCounterTargetConfiguration++;
+  if (buildCounterTargetConfiguration < 3) {
+    checkConfigFile(o.config);
+    checkUnnamed751(o.imports);
+  }
+  buildCounterTargetConfiguration--;
+}
+
 core.int buildCounterType = 0;
 buildType() {
   var o = new api.Type();
   buildCounterType++;
   if (buildCounterType < 3) {
     o.name = "foo";
   }
   buildCounterType--;
   return o;
 }
 
 checkType(api.Type o) {
   buildCounterType++;
   if (buildCounterType < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
   }
   buildCounterType--;
 }
 
-buildUnnamed1664() {
+buildUnnamed752() {
   var o = new core.List<api.Type>();
   o.add(buildType());
   o.add(buildType());
   return o;
 }
 
-checkUnnamed1664(core.List<api.Type> o) {
+checkUnnamed752(core.List<api.Type> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkType(o[0]);
   checkType(o[1]);
 }
 
 core.int buildCounterTypesListResponse = 0;
 buildTypesListResponse() {
   var o = new api.TypesListResponse();
   buildCounterTypesListResponse++;
   if (buildCounterTypesListResponse < 3) {
-    o.types = buildUnnamed1664();
+    o.nextPageToken = "foo";
+    o.types = buildUnnamed752();
   }
   buildCounterTypesListResponse--;
   return o;
 }
 
 checkTypesListResponse(api.TypesListResponse o) {
   buildCounterTypesListResponse++;
   if (buildCounterTypesListResponse < 3) {
-    checkUnnamed1664(o.types);
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    checkUnnamed752(o.types);
   }
   buildCounterTypesListResponse--;
 }
 
 
 main() {
+  unittest.group("obj-schema-ConfigFile", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildConfigFile();
+      var od = new api.ConfigFile.fromJson(o.toJson());
+      checkConfigFile(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Deployment", () {
     unittest.test("to-json--from-json", () {
       var o = buildDeployment();
       var od = new api.Deployment.fromJson(o.toJson());
       checkDeployment(od);
     });
   });
 
 
+  unittest.group("obj-schema-DeploymentUpdate", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDeploymentUpdate();
+      var od = new api.DeploymentUpdate.fromJson(o.toJson());
+      checkDeploymentUpdate(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DeploymentsCancelPreviewRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDeploymentsCancelPreviewRequest();
+      var od = new api.DeploymentsCancelPreviewRequest.fromJson(o.toJson());
+      checkDeploymentsCancelPreviewRequest(od);
+    });
+  });
+
+
   unittest.group("obj-schema-DeploymentsListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildDeploymentsListResponse();
       var od = new api.DeploymentsListResponse.fromJson(o.toJson());
       checkDeploymentsListResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-DeploymentsStopRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDeploymentsStopRequest();
+      var od = new api.DeploymentsStopRequest.fromJson(o.toJson());
+      checkDeploymentsStopRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ImportFile", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildImportFile();
+      var od = new api.ImportFile.fromJson(o.toJson());
+      checkImportFile(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Manifest", () {
     unittest.test("to-json--from-json", () {
       var o = buildManifest();
       var od = new api.Manifest.fromJson(o.toJson());
       checkManifest(od);
     });
   });
 
 
   unittest.group("obj-schema-ManifestsListResponse", () {
@@ skipping 52 matching lines @@
 
   unittest.group("obj-schema-OperationsListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildOperationsListResponse();
       var od = new api.OperationsListResponse.fromJson(o.toJson());
       checkOperationsListResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-ResourceWarningsData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceWarningsData();
+      var od = new api.ResourceWarningsData.fromJson(o.toJson());
+      checkResourceWarningsData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ResourceWarnings", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceWarnings();
+      var od = new api.ResourceWarnings.fromJson(o.toJson());
+      checkResourceWarnings(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Resource", () {
     unittest.test("to-json--from-json", () {
       var o = buildResource();
       var od = new api.Resource.fromJson(o.toJson());
       checkResource(od);
     });
   });
 
 
+  unittest.group("obj-schema-ResourceUpdateErrorErrors", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceUpdateErrorErrors();
+      var od = new api.ResourceUpdateErrorErrors.fromJson(o.toJson());
+      checkResourceUpdateErrorErrors(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ResourceUpdateError", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceUpdateError();
+      var od = new api.ResourceUpdateError.fromJson(o.toJson());
+      checkResourceUpdateError(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ResourceUpdateWarningsData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceUpdateWarningsData();
+      var od = new api.ResourceUpdateWarningsData.fromJson(o.toJson());
+      checkResourceUpdateWarningsData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ResourceUpdateWarnings", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceUpdateWarnings();
+      var od = new api.ResourceUpdateWarnings.fromJson(o.toJson());
+      checkResourceUpdateWarnings(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ResourceUpdate", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceUpdate();
+      var od = new api.ResourceUpdate.fromJson(o.toJson());
+      checkResourceUpdate(od);
+    });
+  });
+
+
   unittest.group("obj-schema-ResourcesListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildResourcesListResponse();
       var od = new api.ResourcesListResponse.fromJson(o.toJson());
       checkResourcesListResponse(od);
     });
   });
 
 
+  unittest.group("obj-schema-TargetConfiguration", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetConfiguration();
+      var od = new api.TargetConfiguration.fromJson(o.toJson());
+      checkTargetConfiguration(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Type", () {
     unittest.test("to-json--from-json", () {
       var o = buildType();
       var od = new api.Type.fromJson(o.toJson());
       checkType(od);
     });
   });
 
 
   unittest.group("obj-schema-TypesListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildTypesListResponse();
       var od = new api.TypesListResponse.fromJson(o.toJson());
       checkTypesListResponse(od);
     });
   });
 
 
   unittest.group("resource-DeploymentsResourceApi", () {
+    unittest.test("method--cancelPreview", () {
+
+      var mock = new HttpServerMock();
+      api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
+      var arg_request = buildDeploymentsCancelPreviewRequest();
+      var arg_project = "foo";
+      var arg_deployment = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.DeploymentsCancelPreviewRequest.fromJson(json);
+        checkDeploymentsCancelPreviewRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+
+        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(buildOperation());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.cancelPreview(arg_request, arg_project, arg_deployment).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
     unittest.test("method--delete", () {
 
       var mock = new HttpServerMock();
       api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
       var arg_project = "foo";
       var arg_deployment = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 72 matching lines @@
         checkDeployment(response);
       })));
     });
 
     unittest.test("method--insert", () {
 
       var mock = new HttpServerMock();
       api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
       var arg_request = buildDeployment();
       var arg_project = "foo";
+      var arg_preview = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Deployment.fromJson(json);
         checkDeployment(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
 
         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["preview"].first, unittest.equals("$arg_preview"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+      res.insert(arg_request, arg_project, preview: arg_preview).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
       var arg_project = "foo";
+      var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
 
         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["filter"].first, unittest.equals(arg_filter));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildDeploymentsListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_project, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DeploymentsListResponse response) {
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DeploymentsListResponse response) {
         checkDeploymentsListResponse(response);
       })));
     });
 
+    unittest.test("method--patch", () {
+
+      var mock = new HttpServerMock();
+      api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
+      var arg_request = buildDeployment();
+      var arg_project = "foo";
+      var arg_deployment = "foo";
+      var arg_createPolicy = "foo";
+      var arg_deletePolicy = "foo";
+      var arg_preview = true;
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Deployment.fromJson(json);
+        checkDeployment(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+
+        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["createPolicy"].first, unittest.equals(arg_createPolicy));
+        unittest.expect(queryMap["deletePolicy"].first, unittest.equals(arg_deletePolicy));
+        unittest.expect(queryMap["preview"].first, unittest.equals("$arg_preview"));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildOperation());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_project, arg_deployment, createPolicy: arg_createPolicy, deletePolicy: arg_deletePolicy, preview: arg_preview).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--stop", () {
+
+      var mock = new HttpServerMock();
+      api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
+      var arg_request = buildDeploymentsStopRequest();
+      var arg_project = "foo";
+      var arg_deployment = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.DeploymentsStopRequest.fromJson(json);
+        checkDeploymentsStopRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+
+        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(buildOperation());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.stop(arg_request, arg_project, arg_deployment).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new HttpServerMock();
+      api.DeploymentsResourceApi res = new api.DeploymentmanagerApi(mock).deployments;
+      var arg_request = buildDeployment();
+      var arg_project = "foo";
+      var arg_deployment = "foo";
+      var arg_createPolicy = "foo";
+      var arg_deletePolicy = "foo";
+      var arg_preview = true;
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Deployment.fromJson(json);
+        checkDeployment(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+
+        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["createPolicy"].first, unittest.equals(arg_createPolicy));
+        unittest.expect(queryMap["deletePolicy"].first, unittest.equals(arg_deletePolicy));
+        unittest.expect(queryMap["preview"].first, unittest.equals("$arg_preview"));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildOperation());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_project, arg_deployment, createPolicy: arg_createPolicy, deletePolicy: arg_deletePolicy, preview: arg_preview).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
   });
 
 
   unittest.group("resource-ManifestsResourceApi", () {
     unittest.test("method--get", () {
 
       var mock = new HttpServerMock();
       api.ManifestsResourceApi res = new api.DeploymentmanagerApi(mock).manifests;
       var arg_project = "foo";
       var arg_deployment = "foo";
@@ skipping 34 matching lines @@
         checkManifest(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.ManifestsResourceApi res = new api.DeploymentmanagerApi(mock).manifests;
       var arg_project = "foo";
       var arg_deployment = "foo";
+      var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
 
         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["filter"].first, unittest.equals(arg_filter));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildManifestsListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_project, arg_deployment, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ManifestsListResponse response) {
+      res.list(arg_project, arg_deployment, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ManifestsListResponse response) {
         checkManifestsListResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-OperationsResourceApi", () {
     unittest.test("method--get", () {
 
@@ skipping 36 matching lines @@
       res.get(arg_project, arg_operation).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.OperationsResourceApi res = new api.DeploymentmanagerApi(mock).operations;
       var arg_project = "foo";
+      var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
 
         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["filter"].first, unittest.equals(arg_filter));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperationsListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_project, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationsListResponse response) {
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationsListResponse response) {
         checkOperationsListResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-ResourcesResourceApi", () {
     unittest.test("method--get", () {
 
@@ skipping 38 matching lines @@
         checkResource(response);
       })));
     });
 
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.ResourcesResourceApi res = new api.DeploymentmanagerApi(mock).resources;
       var arg_project = "foo";
       var arg_deployment = "foo";
+      var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
 
         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["filter"].first, unittest.equals(arg_filter));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildResourcesListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_project, arg_deployment, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ResourcesListResponse response) {
+      res.list(arg_project, arg_deployment, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ResourcesListResponse response) {
         checkResourcesListResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-TypesResourceApi", () {
     unittest.test("method--list", () {
 
       var mock = new HttpServerMock();
       api.TypesResourceApi res = new api.DeploymentmanagerApi(mock).types;
       var arg_project = "foo";
+      var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
 
         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["filter"].first, unittest.equals(arg_filter));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildTypesListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_project, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TypesListResponse response) {
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TypesListResponse response) {
         checkTypesListResponse(response);
       })));
     });
 
   });
 
 
 }