Finish modifying analysis server to make use of code generation.

pkg/analysis_server/lib/src/generated_protocol.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/spec/generate_files".
 
-part of protocol2;
+part of protocol;
+/**
+ * server.getVersion params
+ */
+class ServerGetVersionParams {
+  Request toRequest(String id) {
+    return new Request(id, "server.getVersion", null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is ServerGetVersionParams) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 55877452;
+  }
+}
 
 /**
  * server.getVersion result
  *
  * {
  *   "version": String
  * }
  */
-class ServerGetVersionResult implements HasToJson {
+class ServerGetVersionResult {
   /**
    * The version number of the analysis server.
    */
   String version;
 
   ServerGetVersionResult(this.version);
 
   factory ServerGetVersionResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String version;
       if (json.containsKey("version")) {
         version = jsonDecoder._decodeString(jsonPath + ".version", json["version"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "version");
       }
       return new ServerGetVersionResult(version);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.getVersion result");
     }
   }
 
   factory ServerGetVersionResult.fromResponse(Response response) {
     return new ServerGetVersionResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["version"] = version;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, version.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * server.shutdown params
+ */
+class ServerShutdownParams {
+  Request toRequest(String id) {
+    return new Request(id, "server.shutdown", null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is ServerShutdownParams) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 366630911;
+  }
+}
+/**
+ * server.shutdown result
+ */
+class ServerShutdownResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is ServerShutdownResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 193626532;
+  }
+}
 
 /**
  * server.setSubscriptions params
  *
  * {
  *   "subscriptions": List<ServerService>
  * }
  */
-class ServerSetSubscriptionsParams implements HasToJson {
+class ServerSetSubscriptionsParams {
   /**
    * A list of the services being subscribed to.
    */
   List<ServerService> subscriptions;
 
   ServerSetSubscriptionsParams(this.subscriptions);
 
   factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<ServerService> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ServerService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new ServerSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params");
     }
   }
 
   factory ServerSetSubscriptionsParams.fromRequest(Request request) {
     return new ServerSetSubscriptionsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["subscriptions"] = subscriptions.map((ServerService value) => value.toJson()).toList();
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "server.setSubscriptions", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * server.setSubscriptions result
+ */
+class ServerSetSubscriptionsResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is ServerSetSubscriptionsResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 748820900;
+  }
+}
+/**
+ * server.connected params
+ */
+class ServerConnectedParams {
+  Notification toNotification() {
+    return new Notification("server.connected", null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is ServerConnectedParams) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 509239412;
+  }
+}
 
 /**
  * server.error params
  *
  * {
  *   "fatal": bool
  *   "message": String
  *   "stackTrace": String
  * }
  */
-class ServerErrorParams implements HasToJson {
+class ServerErrorParams {
   /**
    * True if the error is a fatal error, meaning that the server will shutdown
    * automatically after sending this notification.
    */
   bool fatal;
 
   /**
    * The error message indicating what kind of error was encountered.
    */
   String message;
@@ skipping 30 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "stackTrace");
       }
       return new ServerErrorParams(fatal, message, stackTrace);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.error params");
     }
   }
 
   factory ServerErrorParams.fromNotification(Notification notification) {
     return new ServerErrorParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["fatal"] = fatal;
     result["message"] = message;
     result["stackTrace"] = stackTrace;
     return result;
   }
 
@@ skipping 24 matching lines @@
   }
 }
 
 /**
  * server.status params
  *
  * {
  *   "analysis": optional AnalysisStatus
  * }
  */
-class ServerStatusParams implements HasToJson {
+class ServerStatusParams {
   /**
    * The current status of analysis, including whether analysis is being
    * performed and if so what is being analyzed.
    */
   AnalysisStatus analysis;
 
   ServerStatusParams({this.analysis});
 
   factory ServerStatusParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       AnalysisStatus analysis;
       if (json.containsKey("analysis")) {
         analysis = new AnalysisStatus.fromJson(jsonDecoder, jsonPath + ".analysis", json["analysis"]);
       }
       return new ServerStatusParams(analysis: analysis);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.status params");
     }
   }
 
   factory ServerStatusParams.fromNotification(Notification notification) {
     return new ServerStatusParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (analysis != null) {
       result["analysis"] = analysis.toJson();
     }
     return result;
   }
 
@@ skipping 20 matching lines @@
   }
 }
 
 /**
  * analysis.getErrors params
  *
  * {
  *   "file": FilePath
  * }
  */
-class AnalysisGetErrorsParams implements HasToJson {
+class AnalysisGetErrorsParams {
   /**
    * The file for which errors are being requested.
    */
   String file;
 
   AnalysisGetErrorsParams(this.file);
 
   factory AnalysisGetErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       return new AnalysisGetErrorsParams(file);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors params");
     }
   }
 
   factory AnalysisGetErrorsParams.fromRequest(Request request) {
     return new AnalysisGetErrorsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.getErrors", toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * analysis.getErrors result
  *
  * {
  *   "errors": List<AnalysisError>
  * }
  */
-class AnalysisGetErrorsResult implements HasToJson {
+class AnalysisGetErrorsResult {
   /**
    * The errors associated with the file.
    */
   List<AnalysisError> errors;
 
   AnalysisGetErrorsResult(this.errors);
 
   factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<AnalysisError> errors;
       if (json.containsKey("errors")) {
         errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "errors");
       }
       return new AnalysisGetErrorsResult(errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result");
     }
   }
 
   factory AnalysisGetErrorsResult.fromResponse(Response response) {
     return new AnalysisGetErrorsResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 19 matching lines @@
 }
 
 /**
  * analysis.getHover params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class AnalysisGetHoverParams implements HasToJson {
+class AnalysisGetHoverParams {
   /**
    * The file in which hover information is being requested.
    */
   String file;
 
   /**
    * The offset for which hover information is being requested.
    */
   int offset;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new AnalysisGetHoverParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover params");
     }
   }
 
   factory AnalysisGetHoverParams.fromRequest(Request request) {
     return new AnalysisGetHoverParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
   Request toRequest(String id) {
@@ skipping 21 matching lines @@
   }
 }
 
 /**
  * analysis.getHover result
  *
  * {
  *   "hovers": List<HoverInformation>
  * }
  */
-class AnalysisGetHoverResult implements HasToJson {
+class AnalysisGetHoverResult {
   /**
    * The hover information associated with the location. The list will be empty
    * if no information could be determined for the location. The list can
    * contain multiple items if the file is being analyzed in multiple contexts
    * in conflicting ways (such as a part that is included in multiple
    * libraries).
    */
   List<HoverInformation> hovers;
 
   AnalysisGetHoverResult(this.hovers);
@@ skipping 10 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "hovers");
       }
       return new AnalysisGetHoverResult(hovers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result");
     }
   }
 
   factory AnalysisGetHoverResult.fromResponse(Response response) {
     return new AnalysisGetHoverResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["hovers"] = hovers.map((HoverInformation value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, hovers.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * analysis.reanalyze params
+ */
+class AnalysisReanalyzeParams {
+  Request toRequest(String id) {
+    return new Request(id, "analysis.reanalyze", null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisReanalyzeParams) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 613039876;
+  }
+}
+/**
+ * analysis.reanalyze result
+ */
+class AnalysisReanalyzeResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisReanalyzeResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 846803925;
+  }
+}
 
 /**
  * analysis.setAnalysisRoots params
  *
  * {
  *   "included": List<FilePath>
  *   "excluded": List<FilePath>
  * }
  */
-class AnalysisSetAnalysisRootsParams implements HasToJson {
+class AnalysisSetAnalysisRootsParams {
   /**
    * A list of the files and directories that should be analyzed.
    */
   List<String> included;
 
   /**
    * A list of the files and directories within the included directories that
    * should not be analyzed.
    */
   List<String> excluded;
@@ skipping 18 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "excluded");
       }
       return new AnalysisSetAnalysisRootsParams(included, excluded);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params");
     }
   }
 
   factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) {
     return new AnalysisSetAnalysisRootsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["included"] = included;
     result["excluded"] = excluded;
     return result;
   }
 
   Request toRequest(String id) {
@@ skipping 13 matching lines @@
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, included.hashCode);
     hash = _JenkinsSmiHash.combine(hash, excluded.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * analysis.setAnalysisRoots result
+ */
+class AnalysisSetAnalysisRootsResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisSetAnalysisRootsResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 866004753;
+  }
+}
 
 /**
  * analysis.setPriorityFiles params
  *
  * {
  *   "files": List<FilePath>
  * }
  */
-class AnalysisSetPriorityFilesParams implements HasToJson {
+class AnalysisSetPriorityFilesParams {
   /**
    * The files that are to be a priority for analysis.
    */
   List<String> files;
 
   AnalysisSetPriorityFilesParams(this.files);
 
   factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisSetPriorityFilesParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params");
     }
   }
 
   factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
     return new AnalysisSetPriorityFilesParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = files;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.setPriorityFiles", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, files.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * analysis.setPriorityFiles result
+ */
+class AnalysisSetPriorityFilesResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisSetPriorityFilesResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 330050055;
+  }
+}
 
 /**
  * analysis.setSubscriptions params
  *
  * {
  *   "subscriptions": Map<AnalysisService, List<FilePath>>
  * }
  */
-class AnalysisSetSubscriptionsParams implements HasToJson {
+class AnalysisSetSubscriptionsParams {
   /**
    * A table mapping services to a list of the files being subscribed to the
    * service.
    */
   Map<AnalysisService, List<String>> subscriptions;
 
   AnalysisSetSubscriptionsParams(this.subscriptions);
 
   factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Map<AnalysisService, List<String>> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeMap(jsonPath + ".subscriptions", json["subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisService.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new AnalysisSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params");
     }
   }
 
   factory AnalysisSetSubscriptionsParams.fromRequest(Request request) {
     return new AnalysisSetSubscriptionsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["subscriptions"] = mapMap(subscriptions, keyCallback: (AnalysisService value) => value.toJson());
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.setSubscriptions", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * analysis.setSubscriptions result
+ */
+class AnalysisSetSubscriptionsResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisSetSubscriptionsResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 218088493;
+  }
+}
 
 /**
  * analysis.updateContent params
  *
  * {
  *   "files": Map<FilePath, AddContentOverlay | ChangeContentOverlay | RemoveContentOverlay>
  * }
  */
-class AnalysisUpdateContentParams implements HasToJson {
+class AnalysisUpdateContentParams {
   /**
    * A table mapping the files whose content has changed to a description of
    * the content change.
    */
   Map<String, dynamic> files;
 
   AnalysisUpdateContentParams(this.files);
 
   factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Map<String, dynamic> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeMap(jsonPath + ".files", json["files"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeUnion(jsonPath, json, "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.fromJson(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => new ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String jsonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPath, json)}));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisUpdateContentParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params");
     }
   }
 
   factory AnalysisUpdateContentParams.fromRequest(Request request) {
     return new AnalysisUpdateContentParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = mapMap(files, valueCallback: (dynamic value) => value.toJson());
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.updateContent", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, files.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * analysis.updateContent result
+ */
+class AnalysisUpdateContentResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisUpdateContentResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 468798730;
+  }
+}
 
 /**
  * analysis.updateOptions params
  *
  * {
  *   "options": AnalysisOptions
  * }
  */
-class AnalysisUpdateOptionsParams implements HasToJson {
+class AnalysisUpdateOptionsParams {
   /**
    * The options that are to be used to control analysis.
    */
   AnalysisOptions options;
 
   AnalysisUpdateOptionsParams(this.options);
 
   factory AnalysisUpdateOptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       AnalysisOptions options;
       if (json.containsKey("options")) {
         options = new AnalysisOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "options");
       }
       return new AnalysisUpdateOptionsParams(options);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.updateOptions params");
     }
   }
 
   factory AnalysisUpdateOptionsParams.fromRequest(Request request) {
     return new AnalysisUpdateOptionsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["options"] = options.toJson();
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.updateOptions", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, options.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * analysis.updateOptions result
+ */
+class AnalysisUpdateOptionsResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisUpdateOptionsResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 179689467;
+  }
+}
 
 /**
  * analysis.errors params
  *
  * {
  *   "file": FilePath
  *   "errors": List<AnalysisError>
  * }
  */
-class AnalysisErrorsParams implements HasToJson {
+class AnalysisErrorsParams {
   /**
    * The file containing the errors.
    */
   String file;
 
   /**
    * The errors contained in the file.
    */
   List<AnalysisError> errors;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "errors");
       }
       return new AnalysisErrorsParams(file, errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.errors params");
     }
   }
 
   factory AnalysisErrorsParams.fromNotification(Notification notification) {
     return new AnalysisErrorsParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 21 matching lines @@
   }
 }
 
 /**
  * analysis.flushResults params
  *
  * {
  *   "files": List<FilePath>
  * }
  */
-class AnalysisFlushResultsParams implements HasToJson {
+class AnalysisFlushResultsParams {
   /**
    * The files that are no longer being analyzed.
    */
   List<String> files;
 
   AnalysisFlushResultsParams(this.files);
 
   factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisFlushResultsParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params");
     }
   }
 
   factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
     return new AnalysisFlushResultsParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = files;
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.flushResults", toJson());
@@ skipping 19 matching lines @@
 }
 
 /**
  * analysis.folding params
  *
  * {
  *   "file": FilePath
  *   "regions": List<FoldingRegion>
  * }
  */
-class AnalysisFoldingParams implements HasToJson {
+class AnalysisFoldingParams {
   /**
    * The file containing the folding regions.
    */
   String file;
 
   /**
    * The folding regions contained in the file.
    */
   List<FoldingRegion> regions;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisFoldingParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.folding params");
     }
   }
 
   factory AnalysisFoldingParams.fromNotification(Notification notification) {
     return new AnalysisFoldingParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["regions"] = regions.map((FoldingRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 22 matching lines @@
 }
 
 /**
  * analysis.highlights params
  *
  * {
  *   "file": FilePath
  *   "regions": List<HighlightRegion>
  * }
  */
-class AnalysisHighlightsParams implements HasToJson {
+class AnalysisHighlightsParams {
   /**
    * The file containing the highlight regions.
    */
   String file;
 
   /**
    * The highlight regions contained in the file. Each highlight region
    * represents a particular syntactic or semantic meaning associated with some
    * range. Note that the highlight regions that are returned can overlap other
    * highlight regions if there is more than one meaning associated with a
@@ skipping 21 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisHighlightsParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params");
     }
   }
 
   factory AnalysisHighlightsParams.fromNotification(Notification notification) {
     return new AnalysisHighlightsParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["regions"] = regions.map((HighlightRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 22 matching lines @@
 }
 
 /**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
  *   "regions": List<NavigationRegion>
  * }
  */
-class AnalysisNavigationParams implements HasToJson {
+class AnalysisNavigationParams {
   /**
    * The file containing the navigation regions.
    */
   String file;
 
   /**
    * The navigation regions contained in the file. Each navigation region
    * represents a list of targets associated with some range. The lists will
    * usually contain a single target, but can contain more in the case of a
    * part that is included in multiple libraries or in Dart code that is
@@ skipping 22 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisNavigationParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params");
     }
   }
 
   factory AnalysisNavigationParams.fromNotification(Notification notification) {
     return new AnalysisNavigationParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["regions"] = regions.map((NavigationRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 22 matching lines @@
 }
 
 /**
  * analysis.occurrences params
  *
  * {
  *   "file": FilePath
  *   "occurrences": List<Occurrences>
  * }
  */
-class AnalysisOccurrencesParams implements HasToJson {
+class AnalysisOccurrencesParams {
   /**
    * The file in which the references occur.
    */
   String file;
 
   /**
    * The occurrences of references to elements within the file.
    */
   List<Occurrences> occurrences;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "occurrences");
       }
       return new AnalysisOccurrencesParams(file, occurrences);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params");
     }
   }
 
   factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
     return new AnalysisOccurrencesParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["occurrences"] = occurrences.map((Occurrences value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 22 matching lines @@
 }
 
 /**
  * analysis.outline params
  *
  * {
  *   "file": FilePath
  *   "outline": Outline
  * }
  */
-class AnalysisOutlineParams implements HasToJson {
+class AnalysisOutlineParams {
   /**
    * The file with which the outline is associated.
    */
   String file;
 
   /**
    * The outline associated with the file.
    */
   Outline outline;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "outline");
       }
       return new AnalysisOutlineParams(file, outline);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.outline params");
     }
   }
 
   factory AnalysisOutlineParams.fromNotification(Notification notification) {
     return new AnalysisOutlineParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["outline"] = outline.toJson();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 22 matching lines @@
 }
 
 /**
  * analysis.overrides params
  *
  * {
  *   "file": FilePath
  *   "overrides": List<Override>
  * }
  */
-class AnalysisOverridesParams implements HasToJson {
+class AnalysisOverridesParams {
   /**
    * The file with which the overrides are associated.
    */
   String file;
 
   /**
    * The overrides associated with the file.
    */
   List<Override> overrides;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "overrides");
       }
       return new AnalysisOverridesParams(file, overrides);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params");
     }
   }
 
   factory AnalysisOverridesParams.fromNotification(Notification notification) {
     return new AnalysisOverridesParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["overrides"] = overrides.map((Override value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 22 matching lines @@
 }
 
 /**
  * completion.getSuggestions params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class CompletionGetSuggestionsParams implements HasToJson {
+class CompletionGetSuggestionsParams {
   /**
    * The file containing the point at which suggestions are to be made.
    */
   String file;
 
   /**
    * The offset within the file at which suggestions are to be made.
    */
   int offset;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new CompletionGetSuggestionsParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params");
     }
   }
 
   factory CompletionGetSuggestionsParams.fromRequest(Request request) {
     return new CompletionGetSuggestionsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
   Request toRequest(String id) {
@@ skipping 21 matching lines @@
   }
 }
 
 /**
  * completion.getSuggestions result
  *
  * {
  *   "id": CompletionId
  * }
  */
-class CompletionGetSuggestionsResult implements HasToJson {
+class CompletionGetSuggestionsResult {
   /**
    * The identifier used to associate results with this completion request.
    */
   String id;
 
   CompletionGetSuggestionsResult(this.id);
 
   factory CompletionGetSuggestionsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new CompletionGetSuggestionsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result");
     }
   }
 
   factory CompletionGetSuggestionsResult.fromResponse(Response response) {
     return new CompletionGetSuggestionsResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 22 matching lines @@
  * completion.results params
  *
  * {
  *   "id": CompletionId
  *   "replacementOffset": int
  *   "replacementLength": int
  *   "results": List<CompletionSuggestion>
  *   "last": bool
  * }
  */
-class CompletionResultsParams implements HasToJson {
+class CompletionResultsParams {
   /**
    * The id associated with the completion.
    */
   String id;
 
   /**
    * The offset of the start of the text to be replaced. This will be different
    * than the offset used to request the completion suggestions if there was a
    * portion of an identifier before the original offset. In particular, the
    * replacementOffset will be the offset of the beginning of said identifier.
@@ skipping 60 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "last");
       }
       return new CompletionResultsParams(id, replacementOffset, replacementLength, results, last);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.results params");
     }
   }
 
   factory CompletionResultsParams.fromNotification(Notification notification) {
     return new CompletionResultsParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     result["replacementOffset"] = replacementOffset;
     result["replacementLength"] = replacementLength;
     result["results"] = results.map((CompletionSuggestion value) => value.toJson()).toList();
     result["last"] = last;
     return result;
@@ skipping 32 matching lines @@
 
 /**
  * search.findElementReferences params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "includePotential": bool
  * }
  */
-class SearchFindElementReferencesParams implements HasToJson {
+class SearchFindElementReferencesParams {
   /**
    * The file containing the declaration of or reference to the element used to
    * define the search.
    */
   String file;
 
   /**
    * The offset within the file of the declaration of or reference to the
    * element.
    */
@@ skipping 30 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "includePotential");
       }
       return new SearchFindElementReferencesParams(file, offset, includePotential);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences params");
     }
   }
 
   factory SearchFindElementReferencesParams.fromRequest(Request request) {
     return new SearchFindElementReferencesParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["includePotential"] = includePotential;
     return result;
   }
 
@@ skipping 25 matching lines @@
 }
 
 /**
  * search.findElementReferences result
  *
  * {
  *   "id": SearchId
  *   "element": optional Element
  * }
  */
-class SearchFindElementReferencesResult implements HasToJson {
+class SearchFindElementReferencesResult {
   /**
    * The identifier used to associate results with this search request.
    */
   String id;
 
   /**
    * The element referenced or defined at the given offset and whose references
    * will be returned in the search results.
    *
    * If no element was found at the given location, this field will be absent.
@@ skipping 18 matching lines @@
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       }
       return new SearchFindElementReferencesResult(id, element: element);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result");
     }
   }
 
   factory SearchFindElementReferencesResult.fromResponse(Response response) {
     return new SearchFindElementReferencesResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     if (element != null) {
       result["element"] = element.toJson();
     }
     return result;
   }
@@ skipping 23 matching lines @@
   }
 }
 
 /**
  * search.findMemberDeclarations params
  *
  * {
  *   "name": String
  * }
  */
-class SearchFindMemberDeclarationsParams implements HasToJson {
+class SearchFindMemberDeclarationsParams {
   /**
    * The name of the declarations to be found.
    */
   String name;
 
   SearchFindMemberDeclarationsParams(this.name);
 
   factory SearchFindMemberDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       return new SearchFindMemberDeclarationsParams(name);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations params");
     }
   }
 
   factory SearchFindMemberDeclarationsParams.fromRequest(Request request) {
     return new SearchFindMemberDeclarationsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "search.findMemberDeclarations", toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * search.findMemberDeclarations result
  *
  * {
  *   "id": SearchId
  * }
  */
-class SearchFindMemberDeclarationsResult implements HasToJson {
+class SearchFindMemberDeclarationsResult {
   /**
    * The identifier used to associate results with this search request.
    */
   String id;
 
   SearchFindMemberDeclarationsResult(this.id);
 
   factory SearchFindMemberDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new SearchFindMemberDeclarationsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations result");
     }
   }
 
   factory SearchFindMemberDeclarationsResult.fromResponse(Response response) {
     return new SearchFindMemberDeclarationsResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * search.findMemberReferences params
  *
  * {
  *   "name": String
  * }
  */
-class SearchFindMemberReferencesParams implements HasToJson {
+class SearchFindMemberReferencesParams {
   /**
    * The name of the references to be found.
    */
   String name;
 
   SearchFindMemberReferencesParams(this.name);
 
   factory SearchFindMemberReferencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       return new SearchFindMemberReferencesParams(name);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences params");
     }
   }
 
   factory SearchFindMemberReferencesParams.fromRequest(Request request) {
     return new SearchFindMemberReferencesParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "search.findMemberReferences", toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * search.findMemberReferences result
  *
  * {
  *   "id": SearchId
  * }
  */
-class SearchFindMemberReferencesResult implements HasToJson {
+class SearchFindMemberReferencesResult {
   /**
    * The identifier used to associate results with this search request.
    */
   String id;
 
   SearchFindMemberReferencesResult(this.id);
 
   factory SearchFindMemberReferencesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new SearchFindMemberReferencesResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences result");
     }
   }
 
   factory SearchFindMemberReferencesResult.fromResponse(Response response) {
     return new SearchFindMemberReferencesResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * search.findTopLevelDeclarations params
  *
  * {
  *   "pattern": String
  * }
  */
-class SearchFindTopLevelDeclarationsParams implements HasToJson {
+class SearchFindTopLevelDeclarationsParams {
   /**
    * The regular expression used to match the names of the declarations to be
    * found.
    */
   String pattern;
 
   SearchFindTopLevelDeclarationsParams(this.pattern);
 
   factory SearchFindTopLevelDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String pattern;
       if (json.containsKey("pattern")) {
         pattern = jsonDecoder._decodeString(jsonPath + ".pattern", json["pattern"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "pattern");
       }
       return new SearchFindTopLevelDeclarationsParams(pattern);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations params");
     }
   }
 
   factory SearchFindTopLevelDeclarationsParams.fromRequest(Request request) {
     return new SearchFindTopLevelDeclarationsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["pattern"] = pattern;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "search.findTopLevelDeclarations", toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * search.findTopLevelDeclarations result
  *
  * {
  *   "id": SearchId
  * }
  */
-class SearchFindTopLevelDeclarationsResult implements HasToJson {
+class SearchFindTopLevelDeclarationsResult {
   /**
    * The identifier used to associate results with this search request.
    */
   String id;
 
   SearchFindTopLevelDeclarationsResult(this.id);
 
   factory SearchFindTopLevelDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new SearchFindTopLevelDeclarationsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations result");
     }
   }
 
   factory SearchFindTopLevelDeclarationsResult.fromResponse(Response response) {
     return new SearchFindTopLevelDeclarationsResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 19 matching lines @@
 }
 
 /**
  * search.getTypeHierarchy params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class SearchGetTypeHierarchyParams implements HasToJson {
+class SearchGetTypeHierarchyParams {
   /**
    * The file containing the declaration or reference to the type for which a
    * hierarchy is being requested.
    */
   String file;
 
   /**
    * The offset of the name of the type within the file.
    */
   int offset;
@@ skipping 18 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new SearchGetTypeHierarchyParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy params");
     }
   }
 
   factory SearchGetTypeHierarchyParams.fromRequest(Request request) {
     return new SearchGetTypeHierarchyParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
   Request toRequest(String id) {
@@ skipping 21 matching lines @@
   }
 }
 
 /**
  * search.getTypeHierarchy result
  *
  * {
  *   "hierarchyItems": optional List<TypeHierarchyItem>
  * }
  */
-class SearchGetTypeHierarchyResult implements HasToJson {
+class SearchGetTypeHierarchyResult {
   /**
    * A list of the types in the requested hierarchy. The first element of the
    * list is the item representing the type for which the hierarchy was
    * requested. The index of other elements of the list is unspecified, but
    * correspond to the integers used to reference supertype and subtype items
    * within the items.
    *
    * This field will be absent if the code at the given file and offset does
    * not represent a type, or if the file has not been sufficiently analyzed to
    * allow a type hierarchy to be produced.
@@ skipping 18 matching lines @@
         hierarchyItems = <TypeHierarchyItem>[];
       }
       return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result");
     }
   }
 
   factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
     return new SearchGetTypeHierarchyResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (hierarchyItems.isNotEmpty) {
       result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) => value.toJson()).toList();
     }
     return result;
   }
 
@@ skipping 22 matching lines @@
 
 /**
  * search.results params
  *
  * {
  *   "id": SearchId
  *   "results": List<SearchResult>
  *   "last": bool
  * }
  */
-class SearchResultsParams implements HasToJson {
+class SearchResultsParams {
   /**
    * The id associated with the search.
    */
   String id;
 
   /**
    * The search results being reported.
    */
   List<SearchResult> results;
 
@@ skipping 29 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "last");
       }
       return new SearchResultsParams(id, results, last);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.results params");
     }
   }
 
   factory SearchResultsParams.fromNotification(Notification notification) {
     return new SearchResultsParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     result["results"] = results.map((SearchResult value) => value.toJson()).toList();
     result["last"] = last;
     return result;
   }
 
@@ skipping 26 matching lines @@
 
 /**
  * edit.getAssists params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
-class EditGetAssistsParams implements HasToJson {
+class EditGetAssistsParams {
   /**
    * The file containing the code for which assists are being requested.
    */
   String file;
 
   /**
    * The offset of the code for which assists are being requested.
    */
   int offset;
 
@@ skipping 28 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new EditGetAssistsParams(file, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists params");
     }
   }
 
   factory EditGetAssistsParams.fromRequest(Request request) {
     return new EditGetAssistsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
@@ skipping 24 matching lines @@
   }
 }
 
 /**
  * edit.getAssists result
  *
  * {
  *   "assists": List<SourceChange>
  * }
  */
-class EditGetAssistsResult implements HasToJson {
+class EditGetAssistsResult {
   /**
    * The assists that are available at the given location.
    */
   List<SourceChange> assists;
 
   EditGetAssistsResult(this.assists);
 
   factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<SourceChange> assists;
       if (json.containsKey("assists")) {
         assists = jsonDecoder._decodeList(jsonPath + ".assists", json["assists"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "assists");
       }
       return new EditGetAssistsResult(assists);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result");
     }
   }
 
   factory EditGetAssistsResult.fromResponse(Response response) {
     return new EditGetAssistsResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["assists"] = assists.map((SourceChange value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 20 matching lines @@
 
 /**
  * edit.getAvailableRefactorings params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
-class EditGetAvailableRefactoringsParams implements HasToJson {
+class EditGetAvailableRefactoringsParams {
   /**
    * The file containing the code on which the refactoring would be based.
    */
   String file;
 
   /**
    * The offset of the code on which the refactoring would be based.
    */
   int offset;
 
@@ skipping 28 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new EditGetAvailableRefactoringsParams(file, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params");
     }
   }
 
   factory EditGetAvailableRefactoringsParams.fromRequest(Request request) {
     return new EditGetAvailableRefactoringsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
@@ skipping 24 matching lines @@
   }
 }
 
 /**
  * edit.getAvailableRefactorings result
  *
  * {
  *   "kinds": List<RefactoringKind>
  * }
  */
-class EditGetAvailableRefactoringsResult implements HasToJson {
+class EditGetAvailableRefactoringsResult {
   /**
    * The kinds of refactorings that are valid for the given selection.
    */
   List<RefactoringKind> kinds;
 
   EditGetAvailableRefactoringsResult(this.kinds);
 
   factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<RefactoringKind> kinds;
       if (json.containsKey("kinds")) {
         kinds = jsonDecoder._decodeList(jsonPath + ".kinds", json["kinds"], (String jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kinds");
       }
       return new EditGetAvailableRefactoringsResult(kinds);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result");
     }
   }
 
   factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
     return new EditGetAvailableRefactoringsResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kinds"] = kinds.map((RefactoringKind value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 19 matching lines @@
 }
 
 /**
  * edit.getFixes params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class EditGetFixesParams implements HasToJson {
+class EditGetFixesParams {
   /**
    * The file containing the errors for which fixes are being requested.
    */
   String file;
 
   /**
    * The offset used to select the errors for which fixes will be returned.
    */
   int offset;
 
@@ skipping 17 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new EditGetFixesParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes params");
     }
   }
 
   factory EditGetFixesParams.fromRequest(Request request) {
     return new EditGetFixesParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
   Request toRequest(String id) {
@@ skipping 21 matching lines @@
   }
 }
 
 /**
  * edit.getFixes result
  *
  * {
  *   "fixes": List<ErrorFixes>
  * }
  */
-class EditGetFixesResult implements HasToJson {
+class EditGetFixesResult {
   /**
    * The fixes that are available for each of the analysis errors. There is a
    * one-to-one correspondence between the analysis errors in the request and
    * the lists of changes in the response. In particular, it is always the case
    * that errors.length == fixes.length and that fixes[i] is the list of fixes
    * for the error in errors[i]. The list of changes corresponding to an error
    * can be empty if there are no fixes available for that error.
    */
   List<ErrorFixes> fixes;
 
@@ skipping 11 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new EditGetFixesResult(fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result");
     }
   }
 
   factory EditGetFixesResult.fromResponse(Response response) {
     return new EditGetFixesResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["fixes"] = fixes.map((ErrorFixes value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 23 matching lines @@
  *
  * {
  *   "kind": RefactoringKind
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "validateOnly": bool
  *   "options": optional object
  * }
  */
-class EditGetRefactoringParams implements HasToJson {
+class EditGetRefactoringParams {
   /**
    * The kind of refactoring to be performed.
    */
   RefactoringKind kind;
 
   /**
    * The file containing the code involved in the refactoring.
    */
   String file;
 
@@ skipping 64 matching lines @@
         options = json["options"];
       }
       return new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params");
     }
   }
 
   factory EditGetRefactoringParams.fromRequest(Request request) {
     return new EditGetRefactoringParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     result["validateOnly"] = validateOnly;
     if (options != null) {
@@ skipping 38 matching lines @@
 /**
  * edit.getRefactoring result
  *
  * {
  *   "problems": List<RefactoringProblem>
  *   "feedback": optional object
  *   "change": optional SourceChange
  *   "potentialEdits": optional List<String>
  * }
  */
-class EditGetRefactoringResult implements HasToJson {
+class EditGetRefactoringResult {
   /**
    * The status of the refactoring. The array will be empty if there are no
    * known problems.
    */
   List<RefactoringProblem> problems;
 
   /**
    * Data used to provide feedback to the user. The structure of the data is
    * dependent on the kind of refactoring being created. The data that is
    * returned is documented in the section titled Refactorings, labeled as
@@ skipping 51 matching lines @@
         potentialEdits = <String>[];
       }
       return new EditGetRefactoringResult(problems, feedback: feedback, change: change, potentialEdits: potentialEdits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result");
     }
   }
 
   factory EditGetRefactoringResult.fromResponse(Response response) {
     return new EditGetRefactoringResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["problems"] = problems.map((RefactoringProblem value) => value.toJson()).toList();
     if (feedback != null) {
       result["feedback"] = feedback;
     }
     if (change != null) {
       result["change"] = change.toJson();
@@ skipping 33 matching lines @@
   }
 }
 
 /**
  * debug.createContext params
  *
  * {
  *   "contextRoot": FilePath
  * }
  */
-class DebugCreateContextParams implements HasToJson {
+class DebugCreateContextParams {
   /**
    * The path of the Dart or HTML file that will be launched.
    */
   String contextRoot;
 
   DebugCreateContextParams(this.contextRoot);
 
   factory DebugCreateContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String contextRoot;
       if (json.containsKey("contextRoot")) {
         contextRoot = jsonDecoder._decodeString(jsonPath + ".contextRoot", json["contextRoot"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "contextRoot");
       }
       return new DebugCreateContextParams(contextRoot);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.createContext params");
     }
   }
 
   factory DebugCreateContextParams.fromRequest(Request request) {
     return new DebugCreateContextParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["contextRoot"] = contextRoot;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "debug.createContext", toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * debug.createContext result
  *
  * {
  *   "id": DebugContextId
  * }
  */
-class DebugCreateContextResult implements HasToJson {
+class DebugCreateContextResult {
   /**
    * The identifier used to refer to the debugging context that was created.
    */
   String id;
 
   DebugCreateContextResult(this.id);
 
   factory DebugCreateContextResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new DebugCreateContextResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.createContext result");
     }
   }
 
   factory DebugCreateContextResult.fromResponse(Response response) {
     return new DebugCreateContextResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * debug.deleteContext params
  *
  * {
  *   "id": DebugContextId
  * }
  */
-class DebugDeleteContextParams implements HasToJson {
+class DebugDeleteContextParams {
   /**
    * The identifier of the debugging context that is to be deleted.
    */
   String id;
 
   DebugDeleteContextParams(this.id);
 
   factory DebugDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new DebugDeleteContextParams(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.deleteContext params");
     }
   }
 
   factory DebugDeleteContextParams.fromRequest(Request request) {
     return new DebugDeleteContextParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "debug.deleteContext", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * debug.deleteContext result
+ */
+class DebugDeleteContextResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is DebugDeleteContextResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 923895626;
+  }
+}
 
 /**
  * debug.mapUri params
  *
  * {
  *   "id": DebugContextId
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-class DebugMapUriParams implements HasToJson {
+class DebugMapUriParams {
   /**
    * The identifier of the debugging context in which the URI is to be mapped.
    */
   String id;
 
   /**
    * The path of the file to be mapped into a URI.
    */
   String file;
 
@@ skipping 24 matching lines @@
         uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
       }
       return new DebugMapUriParams(id, file: file, uri: uri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.mapUri params");
     }
   }
 
   factory DebugMapUriParams.fromRequest(Request request) {
     return new DebugMapUriParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     if (file != null) {
       result["file"] = file;
     }
     if (uri != null) {
       result["uri"] = uri;
@@ skipping 29 matching lines @@
 }
 
 /**
  * debug.mapUri result
  *
  * {
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-class DebugMapUriResult implements HasToJson {
+class DebugMapUriResult {
   /**
    * The file to which the URI was mapped. This field is omitted if the uri
    * field was not given in the request.
    */
   String file;
 
   /**
    * The URI to which the file path was mapped. This field is omitted if the
    * file field was not given in the request.
    */
@@ skipping 15 matching lines @@
         uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
       }
       return new DebugMapUriResult(file: file, uri: uri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.mapUri result");
     }
   }
 
   factory DebugMapUriResult.fromResponse(Response response) {
     return new DebugMapUriResult.fromJson(
-        new ResponseDecoder(), "result", response.result);
+        new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (file != null) {
       result["file"] = file;
     }
     if (uri != null) {
       result["uri"] = uri;
     }
@@ skipping 25 matching lines @@
   }
 }
 
 /**
  * debug.setSubscriptions params
  *
  * {
  *   "subscriptions": List<DebugService>
  * }
  */
-class DebugSetSubscriptionsParams implements HasToJson {
+class DebugSetSubscriptionsParams {
   /**
    * A list of the services being subscribed to.
    */
   List<DebugService> subscriptions;
 
   DebugSetSubscriptionsParams(this.subscriptions);
 
   factory DebugSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<DebugService> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new DebugService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new DebugSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.setSubscriptions params");
     }
   }
 
   factory DebugSetSubscriptionsParams.fromRequest(Request request) {
     return new DebugSetSubscriptionsParams.fromJson(
-        new RequestDecoder(request), "params", request.params);
+        new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["subscriptions"] = subscriptions.map((DebugService value) => value.toJson()).toList();
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "debug.setSubscriptions", toJson());
@@ skipping 10 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * debug.setSubscriptions result
+ */
+class DebugSetSubscriptionsResult {
+  Response toResponse(String id) {
+    return new Response(id, result: null);
+  }
+
+  @override
+  bool operator==(other) {
+    if (other is DebugSetSubscriptionsResult) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 36732888;
+  }
+}
 
 /**
  * debug.launchData params
  *
  * {
  *   "executables": List<ExecutableFile>
  *   "dartToHtml": Map<FilePath, List<FilePath>>
  *   "htmlToDart": Map<FilePath, List<FilePath>>
  * }
  */
-class DebugLaunchDataParams implements HasToJson {
+class DebugLaunchDataParams {
   /**
    * A list of the files that are executable in the given context. This list
    * replaces any previous list provided for the given context.
    */
   List<ExecutableFile> executables;
 
   /**
    * A mapping from the paths of Dart files that are referenced by HTML files
    * to a list of the HTML files that reference the Dart files.
    */
@@ skipping 31 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "htmlToDart");
       }
       return new DebugLaunchDataParams(executables, dartToHtml, htmlToDart);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.launchData params");
     }
   }
 
   factory DebugLaunchDataParams.fromNotification(Notification notification) {
     return new DebugLaunchDataParams.fromJson(
-        new ResponseDecoder(), "params", notification.params);
+        new ResponseDecoder(), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["executables"] = executables.map((ExecutableFile value) => value.toJson()).toList();
     result["dartToHtml"] = dartToHtml;
     result["htmlToDart"] = htmlToDart;
     return result;
   }
 
@@ skipping 25 matching lines @@
 }
 
 /**
  * AddContentOverlay
  *
  * {
  *   "type": "add"
  *   "content": String
  * }
  */
-class AddContentOverlay implements HasToJson {
+class AddContentOverlay {
   /**
    * The new content of the file.
    */
   String content;
 
   AddContentOverlay(this.content);
 
   factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
@@ skipping 45 matching lines @@
  * AnalysisError
  *
  * {
  *   "severity": ErrorSeverity
  *   "type": ErrorType
  *   "location": Location
  *   "message": String
  *   "correction": optional String
  * }
  */
-class AnalysisError implements HasToJson {
+class AnalysisError {
   /**
    * Returns a list of AnalysisErrors correponding to the given list of Engine
    * errors.
    */
   static List<AnalysisError> listFromEngine(engine.LineInfo lineInfo, List<engine.AnalysisError> errors) =>
       _analysisErrorListFromEngine(lineInfo, errors);
 
   /**
    * The severity of the error.
    */
@@ skipping 112 matching lines @@
  * AnalysisOptions
  *
  * {
  *   "enableAsync": optional bool
  *   "enableDeferredLoading": optional bool
  *   "enableEnums": optional bool
  *   "generateDart2jsHints": optional bool
  *   "generateHints": optional bool
  * }
  */
-class AnalysisOptions implements HasToJson {
+class AnalysisOptions {
   /**
    * True if the client wants to enable support for the proposed async feature.
    */
   bool enableAsync;
 
   /**
    * True if the client wants to enable support for the proposed deferred
    * loading feature.
    */
   bool enableDeferredLoading;
@@ skipping 160 matching lines @@
 }
 
 /**
  * AnalysisStatus
  *
  * {
  *   "analyzing": bool
  *   "analysisTarget": optional String
  * }
  */
-class AnalysisStatus implements HasToJson {
+class AnalysisStatus {
   /**
    * True if analysis is currently being performed.
    */
   bool analyzing;
 
   /**
    * The name of the current target of analysis. This field is omitted if
    * analyzing is false.
    */
   String analysisTarget;
@@ skipping 52 matching lines @@
 }
 
 /**
  * ChangeContentOverlay
  *
  * {
  *   "type": "change"
  *   "edits": List<SourceEdit>
  * }
  */
-class ChangeContentOverlay implements HasToJson {
+class ChangeContentOverlay {
   /**
    * The edits to be applied to the file.
    */
   List<SourceEdit> edits;
 
   ChangeContentOverlay(this.edits);
 
   factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
@@ skipping 106 matching lines @@
  *   "declaringType": optional String
  *   "returnType": optional String
  *   "parameterNames": optional List<String>
  *   "parameterTypes": optional List<String>
  *   "requiredParameterCount": optional int
  *   "positionalParameterCount": optional int
  *   "parameterName": optional String
  *   "parameterType": optional String
  * }
  */
-class CompletionSuggestion implements HasToJson {
+class CompletionSuggestion {
   /**
    * The kind of element being suggested.
    */
   CompletionSuggestionKind kind;
 
   /**
    * The relevance of this completion suggestion.
    */
   CompletionRelevance relevance;
 
@@ skipping 474 matching lines @@
  *
  * {
  *   "kind": ElementKind
  *   "name": String
  *   "location": optional Location
  *   "flags": int
  *   "parameters": optional String
  *   "returnType": optional String
  * }
  */
-class Element implements HasToJson {
+class Element {
   static const int FLAG_ABSTRACT = 0x01;
   static const int FLAG_CONST = 0x02;
   static const int FLAG_FINAL = 0x04;
   static const int FLAG_STATIC = 0x08;
   static const int FLAG_PRIVATE = 0x10;
   static const int FLAG_DEPRECATED = 0x20;
 
   static int makeFlags({isAbstract: false, isConst: false, isFinal: false, isStatic: false, isPrivate: false, isDeprecated: false}) {
     int flags = 0;
     if (isAbstract) flags |= FLAG_ABSTRACT;
@@ skipping 282 matching lines @@
 
 /**
  * Error
  *
  * {
  *   "code": String
  *   "message": String
  *   "data": optional object
  * }
  */
-class Error implements HasToJson {
+class Error {
   /**
    * A code that uniquely identifies the error that occurred.
    */
   String code;
 
   /**
    * A short description of the error.
    */
   String message;
 
@@ skipping 66 matching lines @@
 }
 
 /**
  * ErrorFixes
  *
  * {
  *   "error": AnalysisError
  *   "fixes": List<SourceChange>
  * }
  */
-class ErrorFixes implements HasToJson {
+class ErrorFixes {
   /**
    * The error with which the fixes are associated.
    */
   AnalysisError error;
 
   /**
    * The fixes associated with the error.
    */
   List<SourceChange> fixes;
 
@@ skipping 175 matching lines @@
 }
 
 /**
  * ExecutableFile
  *
  * {
  *   "file": FilePath
  *   "offset": ExecutableKind
  * }
  */
-class ExecutableFile implements HasToJson {
+class ExecutableFile {
   /**
    * The path of the executable file.
    */
   String file;
 
   /**
    * The offset of the region to be highlighted.
    */
   ExecutableKind offset;
 
@@ skipping 160 matching lines @@
 
 /**
  * FoldingRegion
  *
  * {
  *   "kind": FoldingKind
  *   "offset": int
  *   "length": int
  * }
  */
-class FoldingRegion implements HasToJson {
+class FoldingRegion {
   /**
    * The kind of the region.
    */
   FoldingKind kind;
 
   /**
    * The offset of the region to be folded.
    */
   int offset;
 
@@ skipping 66 matching lines @@
 
 /**
  * HighlightRegion
  *
  * {
  *   "type": HighlightRegionType
  *   "offset": int
  *   "length": int
  * }
  */
-class HighlightRegion implements HasToJson {
+class HighlightRegion {
   /**
    * The type of highlight associated with the region.
    */
   HighlightRegionType type;
 
   /**
    * The offset of the region to be highlighted.
    */
   int offset;
 
@@ skipping 282 matching lines @@
  *   "containingLibraryPath": optional String
  *   "containingLibraryName": optional String
  *   "dartdoc": optional String
  *   "elementDescription": optional String
  *   "elementKind": optional String
  *   "parameter": optional String
  *   "propagatedType": optional String
  *   "staticType": optional String
  * }
  */
-class HoverInformation implements HasToJson {
+class HoverInformation {
   /**
    * The offset of the range of characters that encompases the cursor position
    * and has the same hover information as the cursor position.
    */
   int offset;
 
   /**
    * The length of the range of characters that encompases the cursor position
    * and has the same hover information as the cursor position.
    */
@@ skipping 180 matching lines @@
 
 /**
  * LinkedEditGroup
  *
  * {
  *   "positions": List<Position>
  *   "length": int
  *   "suggestions": List<LinkedEditSuggestion>
  * }
  */
-class LinkedEditGroup implements HasToJson {
+class LinkedEditGroup {
   /**
    * The positions of the regions that should be edited simultaneously.
    */
   List<Position> positions;
 
   /**
    * The length of the regions that should be edited simultaneously.
    */
   int length;
 
@@ skipping 86 matching lines @@
 }
 
 /**
  * LinkedEditSuggestion
  *
  * {
  *   "value": String
  *   "kind": LinkedEditSuggestionKind
  * }
  */
-class LinkedEditSuggestion implements HasToJson {
+class LinkedEditSuggestion {
   /**
    * The value that could be used to replace all of the linked edit regions.
    */
   String value;
 
   /**
    * The kind of value being proposed.
    */
   LinkedEditSuggestionKind kind;
 
@@ skipping 108 matching lines @@
  * Location
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "startLine": int
  *   "startColumn": int
  * }
  */
-class Location implements HasToJson {
+class Location {
   /**
    * The file containing the range.
    */
   String file;
 
   /**
    * The offset of the range.
    */
   int offset;
 
@@ skipping 120 matching lines @@
 
 /**
  * NavigationRegion
  *
  * {
  *   "offset": int
  *   "length": int
  *   "targets": List<Element>
  * }
  */
-class NavigationRegion implements HasToJson {
+class NavigationRegion {
   /**
    * The offset of the region from which the user can navigate.
    */
   int offset;
 
   /**
    * The length of the region from which the user can navigate.
    */
   int length;
 
@@ skipping 67 matching lines @@
 
 /**
  * Occurrences
  *
  * {
  *   "element": Element
  *   "offsets": List<int>
  *   "length": int
  * }
  */
-class Occurrences implements HasToJson {
+class Occurrences {
   /**
    * The element that was referenced.
    */
   Element element;
 
   /**
    * The offsets of the name of the referenced element within the file.
    */
   List<int> offsets;
 
@@ skipping 67 matching lines @@
 /**
  * Outline
  *
  * {
  *   "element": Element
  *   "offset": int
  *   "length": int
  *   "children": optional List<Outline>
  * }
  */
-class Outline implements HasToJson {
+class Outline {
   /**
    * A description of the element represented by this node.
    */
   Element element;
 
   /**
    * The offset of the first character of the element. This is different than
    * the offset in the Element, which if the offset of the name of the element.
    * It can be used, for example, to map locations in the file back to an
    * outline.
@@ skipping 91 matching lines @@
 /**
  * Override
  *
  * {
  *   "offset": int
  *   "length": int
  *   "superclassMember": optional OverriddenMember
  *   "interfaceMembers": optional List<OverriddenMember>
  * }
  */
-class Override implements HasToJson {
+class Override {
   /**
    * The offset of the name of the overriding member.
    */
   int offset;
 
   /**
    * The length of the name of the overriding member.
    */
   int length;
 
@@ skipping 89 matching lines @@
 }
 
 /**
  * OverriddenMember
  *
  * {
  *   "element": Element
  *   "className": String
  * }
  */
-class OverriddenMember implements HasToJson {
+class OverriddenMember {
   /**
    * The element that is being overridden.
    */
   Element element;
 
   /**
    * The name of the class in which the member is defined.
    */
   String className;
 
@@ skipping 57 matching lines @@
 }
 
 /**
  * Position
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class Position implements HasToJson {
+class Position {
   /**
    * The file containing the position.
    */
   String file;
 
   /**
    * The offset of the position.
    */
   int offset;
 
@@ skipping 123 matching lines @@
  * RefactoringMethodParameter
  *
  * {
  *   "id": optional String
  *   "kind": RefactoringMethodParameterKind
  *   "type": String
  *   "name": String
  *   "parameters": optional String
  * }
  */
-class RefactoringMethodParameter implements HasToJson {
+class RefactoringMethodParameter {
   /**
    * The unique identifier of the parameter. Clients may omit this field for
    * the parameters they want to add.
    */
   String id;
 
   /**
    * The kind of the parameter.
    */
   RefactoringMethodParameterKind kind;
@@ skipping 147 matching lines @@
 
 /**
  * RefactoringProblem
  *
  * {
  *   "severity": RefactoringProblemSeverity
  *   "message": String
  *   "location": optional Location
  * }
  */
-class RefactoringProblem implements HasToJson {
+class RefactoringProblem {
   /**
    * The severity of the problem being represented.
    */
   RefactoringProblemSeverity severity;
 
   /**
    * A human-readable description of the problem being represented.
    */
   String message;
 
@@ skipping 126 matching lines @@
   String toJson() => name;
 }
 
 /**
  * RemoveContentOverlay
  *
  * {
  *   "type": "remove"
  * }
  */
-class RemoveContentOverlay implements HasToJson {
+class RemoveContentOverlay {
   RemoveContentOverlay();
 
   factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "remove") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "remove");
       }
@@ skipping 31 matching lines @@
 /**
  * SearchResult
  *
  * {
  *   "location": Location
  *   "kind": SearchResultKind
  *   "isPotential": bool
  *   "path": List<Element>
  * }
  */
-class SearchResult implements HasToJson {
+class SearchResult {
   /**
    * The location of the code that matched the search criteria.
    */
   Location location;
 
   /**
    * The kind of element that was found or the kind of reference that was
    * found.
    */
   SearchResultKind kind;
@@ skipping 228 matching lines @@
 /**
  * SourceChange
  *
  * {
  *   "message": String
  *   "edits": List<SourceFileEdit>
  *   "linkedEditGroups": List<LinkedEditGroup>
  *   "selection": optional Position
  * }
  */
-class SourceChange implements HasToJson {
+class SourceChange {
   /**
    * A human-readable description of the change to be applied.
    */
   String message;
 
   /**
    * A list of the edits used to effect the change, grouped by file.
    */
   List<SourceFileEdit> edits;
 
@@ skipping 115 matching lines @@
 /**
  * SourceEdit
  *
  * {
  *   "offset": int
  *   "length": int
  *   "replacement": String
  *   "id": optional String
  * }
  */
-class SourceEdit implements HasToJson {
+class SourceEdit {
   /**
    * Get the result of applying a set of [edits] to the given [code]. Edits are
    * applied in the order they appear in [edits].
    */
   static String applySequence(String code, Iterable<SourceEdit> edits) =>
       _applySequence(code, edits);
 
   /**
    * The offset of the region to be modified.
    */
@@ skipping 109 matching lines @@
 }
 
 /**
  * SourceFileEdit
  *
  * {
  *   "file": FilePath
  *   "edits": List<SourceEdit>
  * }
  */
-class SourceFileEdit implements HasToJson {
+class SourceFileEdit {
   /**
    * The file containing the code to be modified.
    */
   String file;
 
   /**
    * A list of the edits used to effect the change.
    */
   List<SourceEdit> edits;
 
@@ skipping 71 matching lines @@
  * {
  *   "classElement": Element
  *   "displayName": optional String
  *   "memberElement": optional Element
  *   "superclass": optional int
  *   "interfaces": List<int>
  *   "mixins": List<int>
  *   "subclasses": List<int>
  * }
  */
-class TypeHierarchyItem implements HasToJson {
+class TypeHierarchyItem {
   /**
    * The class element represented by this item.
    */
   Element classElement;
 
   /**
    * The name to be displayed for the class. This field will be omitted if the
    * display name is the same as the name of the element. The display name is
    * different if there is additional type information to be displayed, such as
    * type arguments.
@@ skipping 133 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, classElement.hashCode);
     hash = _JenkinsSmiHash.combine(hash, displayName.hashCode);
     hash = _JenkinsSmiHash.combine(hash, memberElement.hashCode);
     hash = _JenkinsSmiHash.combine(hash, superclass.hashCode);
     hash = _JenkinsSmiHash.combine(hash, interfaces.hashCode);
     hash = _JenkinsSmiHash.combine(hash, mixins.hashCode);
     hash = _JenkinsSmiHash.combine(hash, subclasses.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * convertGetterToMethod feedback
+ */
+class ConvertGetterToMethodFeedback {
+  @override
+  bool operator==(other) {
+    if (other is ConvertGetterToMethodFeedback) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 616032599;
+  }
+}
+/**
+ * convertGetterToMethod options
+ */
+class ConvertGetterToMethodOptions {
+  @override
+  bool operator==(other) {
+    if (other is ConvertGetterToMethodOptions) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 488848400;
+  }
+}
+/**
+ * convertMethodToGetter feedback
+ */
+class ConvertMethodToGetterFeedback {
+  @override
+  bool operator==(other) {
+    if (other is ConvertMethodToGetterFeedback) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 165291526;
+  }
+}
+/**
+ * convertMethodToGetter options
+ */
+class ConvertMethodToGetterOptions {
+  @override
+  bool operator==(other) {
+    if (other is ConvertMethodToGetterOptions) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 27952290;
+  }
+}
 
 /**
  * extractLocalVariable feedback
  *
  * {
  *   "names": List<String>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-class ExtractLocalVariableFeedback implements HasToJson {
+class ExtractLocalVariableFeedback {
   /**
    * The proposed names for the local variable.
    */
   List<String> names;
 
   /**
    * The offsets of the expressions that would be replaced by a reference to
    * the variable.
    */
   List<int> offsets;
@@ skipping 74 matching lines @@
 }
 
 /**
  * extractLocalVariable options
  *
  * {
  *   "name": String
  *   "extractAll": bool
  * }
  */
-class ExtractLocalVariableOptions implements HasToJson {
+class ExtractLocalVariableOptions {
   /**
    * The name that the local variable should be given.
    */
   String name;
 
   /**
    * True if all occurrences of the expression within the scope in which the
    * variable will be defined should be replaced by a reference to the local
    * variable. The expression used to initiate the refactoring will always be
    * replaced.
@@ skipping 66 matching lines @@
  *   "length": int
  *   "returnType": String
  *   "names": List<String>
  *   "canCreateGetter": bool
  *   "parameters": List<RefactoringMethodParameter>
  *   "occurrences": int
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-class ExtractMethodFeedback implements HasToJson {
+class ExtractMethodFeedback {
   /**
    * The offset to the beginning of the expression or statements that will be
    * extracted.
    */
   int offset;
 
   /**
    * The length of the expression or statements that will be extracted.
    */
   int length;
@@ skipping 163 matching lines @@
  * extractMethod options
  *
  * {
  *   "returnType": String
  *   "createGetter": bool
  *   "name": String
  *   "parameters": List<RefactoringMethodParameter>
  *   "extractAll": bool
  * }
  */
-class ExtractMethodOptions implements HasToJson {
+class ExtractMethodOptions {
   /**
    * The return type that should be defined for the method.
    */
   String returnType;
 
   /**
    * True if a getter should be created rather than a method. It is an error if
    * this field is true and the list of parameters is non-empty.
    */
   bool createGetter;
@@ skipping 101 matching lines @@
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
     hash = _JenkinsSmiHash.combine(hash, createGetter.hashCode);
     hash = _JenkinsSmiHash.combine(hash, name.hashCode);
     hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
     hash = _JenkinsSmiHash.combine(hash, extractAll.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+/**
+ * inlineLocalVariable feedback
+ */
+class InlineLocalVariableFeedback {
+  @override
+  bool operator==(other) {
+    if (other is InlineLocalVariableFeedback) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 247971243;
+  }
+}
+/**
+ * inlineLocalVariable options
+ */
+class InlineLocalVariableOptions {
+  @override
+  bool operator==(other) {
+    if (other is InlineLocalVariableOptions) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 540364977;
+  }
+}
+/**
+ * inlineMethod feedback
+ */
+class InlineMethodFeedback {
+  @override
+  bool operator==(other) {
+    if (other is InlineMethodFeedback) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return 882400079;
+  }
+}
 
 /**
  * inlineMethod options
  *
  * {
  *   "deleteSource": bool
  *   "inlineAll": bool
  * }
  */
-class InlineMethodOptions implements HasToJson {
+class InlineMethodOptions {
   /**
    * True if the method being inlined should be removed. It is an error if this
    * field is true and inlineAll is false.
    */
   bool deleteSource;
 
   /**
    * True if all invocations of the method should be inlined, or false if only
    * the invocation site used to create this refactoring should be inlined.
    */
@@ skipping 58 matching lines @@
 }
 
 /**
  * rename feedback
  *
  * {
  *   "offset": int
  *   "length": int
  * }
  */
-class RenameFeedback implements HasToJson {
+class RenameFeedback {
   /**
    * The offset to the beginning of the name selected to be renamed.
    */
   int offset;
 
   /**
    * The length of the name selected to be renamed.
    */
   int length;
 
@@ skipping 55 matching lines @@
   }
 }
 
 /**
  * rename options
  *
  * {
  *   "newName": String
  * }
  */
-class RenameOptions implements HasToJson {
+class RenameOptions {
   /**
    * The name that the element should have after the refactoring.
    */
   String newName;
 
   RenameOptions(this.newName);
 
   factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
@@ skipping 33 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }