Move the wire protocol support into the public API

pkg/analysis_server/lib/plugin/protocol/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/tool/spec/generate_files".
 
-part of protocol;
+part of analysis_server.plugin.protocol.protocol;
+
 /**
  * server.getVersion params
+ *
+ * Clients are not expected to subtype this class.
  */
 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
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ServerGetVersionResult implements HasToJson {
   String _version;
 
   /**
    * The version number of the analysis server.
    */
   String get version => _version;
 
   /**
    * The version number of the analysis server.
    */
   void set version(String value) {
     assert(value != null);
     this._version = value;
   }
 
   ServerGetVersionResult(String version) {
     this.version = 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"]);
+        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", json);
     }
   }
 
   factory ServerGetVersionResult.fromResponse(Response response) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is ServerGetVersionResult) {
       return version == other.version;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, version.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, version.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * server.shutdown params
+ *
+ * Clients are not expected to subtype this class.
  */
 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
+ *
+ * Clients are not expected to subtype this class.
  */
 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>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ServerSetSubscriptionsParams implements HasToJson {
   List<ServerService> _subscriptions;
 
   /**
    * A list of the services being subscribed to.
    */
   List<ServerService> get subscriptions => _subscriptions;
 
   /**
    * A list of the services being subscribed to.
    */
   void set subscriptions(List<ServerService> value) {
     assert(value != null);
     this._subscriptions = value;
   }
 
   ServerSetSubscriptionsParams(List<ServerService> subscriptions) {
     this.subscriptions = 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));
+        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", json);
     }
   }
 
   factory ServerSetSubscriptionsParams.fromRequest(Request request) {
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "server.setSubscriptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ServerSetSubscriptionsParams) {
-      return _listEqual(subscriptions, other.subscriptions, (ServerService a, ServerService b) => a == b);
+      return listEqual(subscriptions, other.subscriptions, (ServerService a, ServerService b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, subscriptions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * server.setSubscriptions result
+ *
+ * Clients are not expected to subtype this class.
  */
 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
  *
  * {
  *   "version": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ServerConnectedParams implements HasToJson {
   String _version;
 
   /**
    * The version number of the analysis server.
    */
   String get version => _version;
 
   /**
    * The version number of the analysis server.
    */
   void set version(String value) {
     assert(value != null);
     this._version = value;
   }
 
   ServerConnectedParams(String version) {
     this.version = version;
   }
 
   factory ServerConnectedParams.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"]);
+        version = jsonDecoder.decodeString(jsonPath + ".version", json["version"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "version");
       }
       return new ServerConnectedParams(version);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.connected params", json);
     }
   }
 
   factory ServerConnectedParams.fromNotification(Notification notification) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is ServerConnectedParams) {
       return version == other.version;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, version.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, version.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * server.error params
  *
  * {
  *   "isFatal": bool
  *   "message": String
  *   "stackTrace": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ServerErrorParams implements HasToJson {
   bool _isFatal;
 
   String _message;
 
   String _stackTrace;
 
   /**
    * True if the error is a fatal error, meaning that the server will shutdown
@@ skipping 44 matching lines @@
     this.stackTrace = stackTrace;
   }
 
   factory ServerErrorParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool isFatal;
       if (json.containsKey("isFatal")) {
-        isFatal = jsonDecoder._decodeBool(jsonPath + ".isFatal", json["isFatal"]);
+        isFatal = jsonDecoder.decodeBool(jsonPath + ".isFatal", json["isFatal"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isFatal");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
+        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       String stackTrace;
       if (json.containsKey("stackTrace")) {
-        stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
+        stackTrace = jsonDecoder.decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "stackTrace");
       }
       return new ServerErrorParams(isFatal, message, stackTrace);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.error params", json);
     }
   }
 
   factory ServerErrorParams.fromNotification(Notification notification) {
@@ skipping 22 matching lines @@
       return isFatal == other.isFatal &&
           message == other.message &&
           stackTrace == other.stackTrace;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, isFatal.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, message.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, stackTrace.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, isFatal.hashCode);
+    hash = JenkinsSmiHash.combine(hash, message.hashCode);
+    hash = JenkinsSmiHash.combine(hash, stackTrace.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * server.status params
  *
  * {
  *   "analysis": optional AnalysisStatus
  *   "pub": optional PubStatus
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ServerStatusParams implements HasToJson {
   AnalysisStatus _analysis;
 
   PubStatus _pub;
 
   /**
    * The current status of analysis, including whether analysis is being
    * performed and if so what is being analyzed.
    */
@@ skipping 73 matching lines @@
     if (other is ServerStatusParams) {
       return analysis == other.analysis &&
           pub == other.pub;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, analysis.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, pub.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, analysis.hashCode);
+    hash = JenkinsSmiHash.combine(hash, pub.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getErrors params
  *
  * {
  *   "file": FilePath
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetErrorsParams implements HasToJson {
   String _file;
 
   /**
    * The file for which errors are being requested.
    */
   String get file => _file;
 
   /**
    * The file for which errors are being requested.
    */
   void set file(String value) {
     assert(value != null);
     this._file = value;
   }
 
   AnalysisGetErrorsParams(String file) {
     this.file = 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"]);
+        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", json);
     }
   }
 
   factory AnalysisGetErrorsParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is AnalysisGetErrorsParams) {
       return file == other.file;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getErrors result
  *
  * {
  *   "errors": List<AnalysisError>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetErrorsResult implements HasToJson {
   List<AnalysisError> _errors;
 
   /**
    * The errors associated with the file.
    */
   List<AnalysisError> get errors => _errors;
 
   /**
    * The errors associated with the file.
    */
   void set errors(List<AnalysisError> value) {
     assert(value != null);
     this._errors = value;
   }
 
   AnalysisGetErrorsResult(List<AnalysisError> errors) {
     this.errors = 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));
+        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", json);
     }
   }
 
   factory AnalysisGetErrorsResult.fromResponse(Response response) {
@@ skipping 10 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetErrorsResult) {
-      return _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
+      return listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, errors.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, errors.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getHover params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetHoverParams implements HasToJson {
   String _file;
 
   int _offset;
 
   /**
    * The file in which hover information is being requested.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.offset = offset;
   }
 
   factory AnalysisGetHoverParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new AnalysisGetHoverParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover params", json);
     }
   }
 
   factory AnalysisGetHoverParams.fromRequest(Request request) {
@@ skipping 20 matching lines @@
     if (other is AnalysisGetHoverParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getHover result
  *
  * {
  *   "hovers": List<HoverInformation>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetHoverResult implements HasToJson {
   List<HoverInformation> _hovers;
 
   /**
    * 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).
@@ skipping 16 matching lines @@
     this.hovers = hovers;
   }
 
   factory AnalysisGetHoverResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<HoverInformation> hovers;
       if (json.containsKey("hovers")) {
-        hovers = jsonDecoder._decodeList(jsonPath + ".hovers", json["hovers"], (String jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, jsonPath, json));
+        hovers = jsonDecoder.decodeList(jsonPath + ".hovers", json["hovers"], (String jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "hovers");
       }
       return new AnalysisGetHoverResult(hovers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result", json);
     }
   }
 
   factory AnalysisGetHoverResult.fromResponse(Response response) {
@@ skipping 10 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetHoverResult) {
-      return _listEqual(hovers, other.hovers, (HoverInformation a, HoverInformation b) => a == b);
+      return listEqual(hovers, other.hovers, (HoverInformation a, HoverInformation b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, hovers.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, hovers.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.getLibraryDependencies params
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetLibraryDependenciesParams {
   Request toRequest(String id) {
     return new Request(id, "analysis.getLibraryDependencies", null);
   }
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetLibraryDependenciesParams) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 246577680;
   }
 }
 
 /**
  * analysis.getLibraryDependencies result
  *
  * {
  *   "libraries": List<FilePath>
  *   "packageMap": Map<String, Map<String, List<FilePath>>>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetLibraryDependenciesResult implements HasToJson {
   List<String> _libraries;
 
   Map<String, Map<String, List<String>>> _packageMap;
 
   /**
    * A list of the paths of library elements referenced by files in existing
    * analysis roots.
    */
@@ skipping 28 matching lines @@
     this.packageMap = packageMap;
   }
 
   factory AnalysisGetLibraryDependenciesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> libraries;
       if (json.containsKey("libraries")) {
-        libraries = jsonDecoder._decodeList(jsonPath + ".libraries", json["libraries"], jsonDecoder._decodeString);
+        libraries = jsonDecoder.decodeList(jsonPath + ".libraries", json["libraries"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "libraries");
       }
       Map<String, Map<String, List<String>>> packageMap;
       if (json.containsKey("packageMap")) {
-        packageMap = jsonDecoder._decodeMap(jsonPath + ".packageMap", json["packageMap"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeMap(jsonPath, json, valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString)));
+        packageMap = jsonDecoder.decodeMap(jsonPath + ".packageMap", json["packageMap"], valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeMap(jsonPath, json, valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeList(jsonPath, json, jsonDecoder.decodeString)));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "packageMap");
       }
       return new AnalysisGetLibraryDependenciesResult(libraries, packageMap);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getLibraryDependencies result", json);
     }
   }
 
   factory AnalysisGetLibraryDependenciesResult.fromResponse(Response response) {
@@ skipping 11 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetLibraryDependenciesResult) {
-      return _listEqual(libraries, other.libraries, (String a, String b) => a == b) &&
-          _mapEqual(packageMap, other.packageMap, (Map<String, List<String>> a, Map<String, List<String>> b) => _mapEqual(a, b, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b)));
+      return listEqual(libraries, other.libraries, (String a, String b) => a == b) &&
+          mapEqual(packageMap, other.packageMap, (Map<String, List<String>> a, Map<String, List<String>> b) => mapEqual(a, b, (List<String> a, List<String> b) => listEqual(a, b, (String a, String b) => a == b)));
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, libraries.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, packageMap.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, libraries.hashCode);
+    hash = JenkinsSmiHash.combine(hash, packageMap.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getNavigation params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetNavigationParams implements HasToJson {
   String _file;
 
   int _offset;
 
   int _length;
 
   /**
    * The file in which navigation information is being requested.
@@ skipping 44 matching lines @@
     this.length = length;
   }
 
   factory AnalysisGetNavigationParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new AnalysisGetNavigationParams(file, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation params", json);
     }
   }
 
   factory AnalysisGetNavigationParams.fromRequest(Request request) {
@@ skipping 22 matching lines @@
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getNavigation result
  *
  * {
  *   "files": List<FilePath>
  *   "targets": List<NavigationTarget>
  *   "regions": List<NavigationRegion>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisGetNavigationResult implements HasToJson {
   List<String> _files;
 
   List<NavigationTarget> _targets;
 
   List<NavigationRegion> _regions;
 
   /**
    * A list of the paths of files that are referenced by the navigation
@@ skipping 44 matching lines @@
     this.regions = regions;
   }
 
   factory AnalysisGetNavigationResult.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);
+        files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       List<NavigationTarget> targets;
       if (json.containsKey("targets")) {
-        targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
+        targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "targets");
       }
       List<NavigationRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisGetNavigationResult(files, targets, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result", json);
     }
   }
 
   factory AnalysisGetNavigationResult.fromResponse(Response response) {
@@ skipping 12 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetNavigationResult) {
-      return _listEqual(files, other.files, (String a, String b) => a == b) &&
-          _listEqual(targets, other.targets, (NavigationTarget a, NavigationTarget b) => a == b) &&
-          _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b);
+      return listEqual(files, other.files, (String a, String b) => a == b) &&
+          listEqual(targets, other.targets, (NavigationTarget a, NavigationTarget b) => a == b) &&
+          listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, files.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, targets.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, files.hashCode);
+    hash = JenkinsSmiHash.combine(hash, targets.hashCode);
+    hash = JenkinsSmiHash.combine(hash, regions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.reanalyze params
  *
  * {
  *   "roots": optional List<FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisReanalyzeParams implements HasToJson {
   List<String> _roots;
 
   /**
    * A list of the analysis roots that are to be re-analyzed.
    */
   List<String> get roots => _roots;
 
   /**
    * A list of the analysis roots that are to be re-analyzed.
    */
   void set roots(List<String> value) {
     this._roots = value;
   }
 
   AnalysisReanalyzeParams({List<String> roots}) {
     this.roots = roots;
   }
 
   factory AnalysisReanalyzeParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> roots;
       if (json.containsKey("roots")) {
-        roots = jsonDecoder._decodeList(jsonPath + ".roots", json["roots"], jsonDecoder._decodeString);
+        roots = jsonDecoder.decodeList(jsonPath + ".roots", json["roots"], jsonDecoder.decodeString);
       }
       return new AnalysisReanalyzeParams(roots: roots);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params", json);
     }
   }
 
   factory AnalysisReanalyzeParams.fromRequest(Request request) {
     return new AnalysisReanalyzeParams.fromJson(
         new RequestDecoder(request), "params", request._params);
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "analysis.reanalyze", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisReanalyzeParams) {
-      return _listEqual(roots, other.roots, (String a, String b) => a == b);
+      return listEqual(roots, other.roots, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, roots.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, roots.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.reanalyze result
+ *
+ * Clients are not expected to subtype this class.
  */
 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>
  *   "packageRoots": optional Map<FilePath, FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisSetAnalysisRootsParams implements HasToJson {
   List<String> _included;
 
   List<String> _excluded;
 
   Map<String, String> _packageRoots;
 
   /**
    * A list of the files and directories that should be analyzed.
@@ skipping 63 matching lines @@
     this.packageRoots = packageRoots;
   }
 
   factory AnalysisSetAnalysisRootsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> included;
       if (json.containsKey("included")) {
-        included = jsonDecoder._decodeList(jsonPath + ".included", json["included"], jsonDecoder._decodeString);
+        included = jsonDecoder.decodeList(jsonPath + ".included", json["included"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "included");
       }
       List<String> excluded;
       if (json.containsKey("excluded")) {
-        excluded = jsonDecoder._decodeList(jsonPath + ".excluded", json["excluded"], jsonDecoder._decodeString);
+        excluded = jsonDecoder.decodeList(jsonPath + ".excluded", json["excluded"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "excluded");
       }
       Map<String, String> packageRoots;
       if (json.containsKey("packageRoots")) {
-        packageRoots = jsonDecoder._decodeMap(jsonPath + ".packageRoots", json["packageRoots"], valueDecoder: jsonDecoder._decodeString);
+        packageRoots = jsonDecoder.decodeMap(jsonPath + ".packageRoots", json["packageRoots"], valueDecoder: jsonDecoder.decodeString);
       }
       return new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots: packageRoots);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params", json);
     }
   }
 
   factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) {
     return new AnalysisSetAnalysisRootsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
@@ skipping 12 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "analysis.setAnalysisRoots", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetAnalysisRootsParams) {
-      return _listEqual(included, other.included, (String a, String b) => a == b) &&
-          _listEqual(excluded, other.excluded, (String a, String b) => a == b) &&
-          _mapEqual(packageRoots, other.packageRoots, (String a, String b) => a == b);
+      return listEqual(included, other.included, (String a, String b) => a == b) &&
+          listEqual(excluded, other.excluded, (String a, String b) => a == b) &&
+          mapEqual(packageRoots, other.packageRoots, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, included.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, excluded.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, packageRoots.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, included.hashCode);
+    hash = JenkinsSmiHash.combine(hash, excluded.hashCode);
+    hash = JenkinsSmiHash.combine(hash, packageRoots.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.setAnalysisRoots result
+ *
+ * Clients are not expected to subtype this class.
  */
 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.setGeneralSubscriptions params
  *
  * {
  *   "subscriptions": List<GeneralAnalysisService>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisSetGeneralSubscriptionsParams implements HasToJson {
   List<GeneralAnalysisService> _subscriptions;
 
   /**
    * A list of the services being subscribed to.
    */
   List<GeneralAnalysisService> get subscriptions => _subscriptions;
 
   /**
    * A list of the services being subscribed to.
    */
   void set subscriptions(List<GeneralAnalysisService> value) {
     assert(value != null);
     this._subscriptions = value;
   }
 
   AnalysisSetGeneralSubscriptionsParams(List<GeneralAnalysisService> subscriptions) {
     this.subscriptions = subscriptions;
   }
 
   factory AnalysisSetGeneralSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<GeneralAnalysisService> subscriptions;
       if (json.containsKey("subscriptions")) {
-        subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new GeneralAnalysisService.fromJson(jsonDecoder, jsonPath, json));
+        subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new GeneralAnalysisService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new AnalysisSetGeneralSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setGeneralSubscriptions params", json);
     }
   }
 
   factory AnalysisSetGeneralSubscriptionsParams.fromRequest(Request request) {
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "analysis.setGeneralSubscriptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetGeneralSubscriptionsParams) {
-      return _listEqual(subscriptions, other.subscriptions, (GeneralAnalysisService a, GeneralAnalysisService b) => a == b);
+      return listEqual(subscriptions, other.subscriptions, (GeneralAnalysisService a, GeneralAnalysisService b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, subscriptions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.setGeneralSubscriptions result
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisSetGeneralSubscriptionsResult {
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetGeneralSubscriptionsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 386759562;
   }
 }
 
 /**
  * analysis.setPriorityFiles params
  *
  * {
  *   "files": List<FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisSetPriorityFilesParams implements HasToJson {
   List<String> _files;
 
   /**
    * The files that are to be a priority for analysis.
    */
   List<String> get files => _files;
 
   /**
    * The files that are to be a priority for analysis.
    */
   void set files(List<String> value) {
     assert(value != null);
     this._files = value;
   }
 
   AnalysisSetPriorityFilesParams(List<String> files) {
     this.files = 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);
+        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", json);
     }
   }
 
   factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "analysis.setPriorityFiles", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetPriorityFilesParams) {
-      return _listEqual(files, other.files, (String a, String b) => a == b);
+      return listEqual(files, other.files, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, files.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, files.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.setPriorityFiles result
+ *
+ * Clients are not expected to subtype this class.
  */
 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>>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisSetSubscriptionsParams implements HasToJson {
   Map<AnalysisService, List<String>> _subscriptions;
 
   /**
    * A table mapping services to a list of the files being subscribed to the
    * service.
    */
   Map<AnalysisService, List<String>> get subscriptions => _subscriptions;
 
@@ skipping 10 matching lines @@
     this.subscriptions = 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));
+        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", json);
     }
   }
 
   factory AnalysisSetSubscriptionsParams.fromRequest(Request request) {
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "analysis.setSubscriptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetSubscriptionsParams) {
-      return _mapEqual(subscriptions, other.subscriptions, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b));
+      return mapEqual(subscriptions, other.subscriptions, (List<String> a, List<String> b) => listEqual(a, b, (String a, String b) => a == b));
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, subscriptions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.setSubscriptions result
+ *
+ * Clients are not expected to subtype this class.
  */
 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>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisUpdateContentParams implements HasToJson {
   Map<String, dynamic> _files;
 
   /**
    * A table mapping the files whose content has changed to a description of
    * the content change.
    */
   Map<String, dynamic> get files => _files;
 
@@ skipping 10 matching lines @@
     this.files = 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)}));
+        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", json);
     }
   }
 
   factory AnalysisUpdateContentParams.fromRequest(Request request) {
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "analysis.updateContent", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisUpdateContentParams) {
-      return _mapEqual(files, other.files, (dynamic a, dynamic b) => a == b);
+      return mapEqual(files, other.files, (dynamic a, dynamic b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, files.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, files.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.updateContent result
  *
  * {
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisUpdateContentResult implements HasToJson {
   AnalysisUpdateContentResult();
 
   factory AnalysisUpdateContentResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       return new AnalysisUpdateContentResult();
@@ skipping 23 matching lines @@
   bool operator==(other) {
     if (other is AnalysisUpdateContentResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    return _JenkinsSmiHash.finish(hash);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.updateOptions params
  *
  * {
  *   "options": AnalysisOptions
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisUpdateOptionsParams implements HasToJson {
   AnalysisOptions _options;
 
   /**
    * The options that are to be used to control analysis.
    */
   AnalysisOptions get options => _options;
 
   /**
@@ skipping 47 matching lines @@
   bool operator==(other) {
     if (other is AnalysisUpdateOptionsParams) {
       return options == other.options;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, options.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, options.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * analysis.updateOptions result
+ *
+ * Clients are not expected to subtype this class.
  */
 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.analyzedFiles params
  *
  * {
  *   "directories": List<FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisAnalyzedFilesParams implements HasToJson {
   List<String> _directories;
 
   /**
    * A list of the paths of the files that are being analyzed.
    */
   List<String> get directories => _directories;
 
   /**
    * A list of the paths of the files that are being analyzed.
    */
   void set directories(List<String> value) {
     assert(value != null);
     this._directories = value;
   }
 
   AnalysisAnalyzedFilesParams(List<String> directories) {
     this.directories = directories;
   }
 
   factory AnalysisAnalyzedFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> directories;
       if (json.containsKey("directories")) {
-        directories = jsonDecoder._decodeList(jsonPath + ".directories", json["directories"], jsonDecoder._decodeString);
+        directories = jsonDecoder.decodeList(jsonPath + ".directories", json["directories"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "directories");
       }
       return new AnalysisAnalyzedFilesParams(directories);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.analyzedFiles params", json);
     }
   }
 
   factory AnalysisAnalyzedFilesParams.fromNotification(Notification notification) {
@@ skipping 10 matching lines @@
   Notification toNotification() {
     return new Notification("analysis.analyzedFiles", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisAnalyzedFilesParams) {
-      return _listEqual(directories, other.directories, (String a, String b) => a == b);
+      return listEqual(directories, other.directories, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, directories.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, directories.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.errors params
  *
  * {
  *   "file": FilePath
  *   "errors": List<AnalysisError>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisErrorsParams implements HasToJson {
   String _file;
 
   List<AnalysisError> _errors;
 
   /**
    * The file containing the errors.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.errors = errors;
   }
 
   factory AnalysisErrorsParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<AnalysisError> errors;
       if (json.containsKey("errors")) {
-        errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
+        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 AnalysisErrorsParams(file, errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.errors params", json);
     }
   }
 
   factory AnalysisErrorsParams.fromNotification(Notification notification) {
@@ skipping 12 matching lines @@
     return new Notification("analysis.errors", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisErrorsParams) {
       return file == other.file &&
-          _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
+          listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, errors.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, errors.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.flushResults params
  *
  * {
  *   "files": List<FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisFlushResultsParams implements HasToJson {
   List<String> _files;
 
   /**
    * The files that are no longer being analyzed.
    */
   List<String> get files => _files;
 
   /**
    * The files that are no longer being analyzed.
    */
   void set files(List<String> value) {
     assert(value != null);
     this._files = value;
   }
 
   AnalysisFlushResultsParams(List<String> files) {
     this.files = 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);
+        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", json);
     }
   }
 
   factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
@@ skipping 10 matching lines @@
   Notification toNotification() {
     return new Notification("analysis.flushResults", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisFlushResultsParams) {
-      return _listEqual(files, other.files, (String a, String b) => a == b);
+      return listEqual(files, other.files, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, files.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, files.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.folding params
  *
  * {
  *   "file": FilePath
  *   "regions": List<FoldingRegion>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisFoldingParams implements HasToJson {
   String _file;
 
   List<FoldingRegion> _regions;
 
   /**
    * The file containing the folding regions.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.regions = regions;
   }
 
   factory AnalysisFoldingParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<FoldingRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisFoldingParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.folding params", json);
     }
   }
 
   factory AnalysisFoldingParams.fromNotification(Notification notification) {
@@ skipping 12 matching lines @@
     return new Notification("analysis.folding", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisFoldingParams) {
       return file == other.file &&
-          _listEqual(regions, other.regions, (FoldingRegion a, FoldingRegion b) => a == b);
+          listEqual(regions, other.regions, (FoldingRegion a, FoldingRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, regions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.highlights params
  *
  * {
  *   "file": FilePath
  *   "regions": List<HighlightRegion>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisHighlightsParams implements HasToJson {
   String _file;
 
   List<HighlightRegion> _regions;
 
   /**
    * The file containing the highlight regions.
    */
   String get file => _file;
@@ skipping 32 matching lines @@
     this.regions = regions;
   }
 
   factory AnalysisHighlightsParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<HighlightRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisHighlightsParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params", json);
     }
   }
 
   factory AnalysisHighlightsParams.fromNotification(Notification notification) {
@@ skipping 12 matching lines @@
     return new Notification("analysis.highlights", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisHighlightsParams) {
       return file == other.file &&
-          _listEqual(regions, other.regions, (HighlightRegion a, HighlightRegion b) => a == b);
+          listEqual(regions, other.regions, (HighlightRegion a, HighlightRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, regions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.implemented params
  *
  * {
  *   "file": FilePath
  *   "classes": List<ImplementedClass>
  *   "members": List<ImplementedMember>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisImplementedParams implements HasToJson {
   String _file;
 
   List<ImplementedClass> _classes;
 
   List<ImplementedMember> _members;
 
   /**
    * The file with which the implementations are associated.
@@ skipping 40 matching lines @@
     this.members = members;
   }
 
   factory AnalysisImplementedParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<ImplementedClass> classes;
       if (json.containsKey("classes")) {
-        classes = jsonDecoder._decodeList(jsonPath + ".classes", json["classes"], (String jsonPath, Object json) => new ImplementedClass.fromJson(jsonDecoder, jsonPath, json));
+        classes = jsonDecoder.decodeList(jsonPath + ".classes", json["classes"], (String jsonPath, Object json) => new ImplementedClass.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "classes");
       }
       List<ImplementedMember> members;
       if (json.containsKey("members")) {
-        members = jsonDecoder._decodeList(jsonPath + ".members", json["members"], (String jsonPath, Object json) => new ImplementedMember.fromJson(jsonDecoder, jsonPath, json));
+        members = jsonDecoder.decodeList(jsonPath + ".members", json["members"], (String jsonPath, Object json) => new ImplementedMember.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "members");
       }
       return new AnalysisImplementedParams(file, classes, members);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.implemented params", json);
     }
   }
 
   factory AnalysisImplementedParams.fromNotification(Notification notification) {
@@ skipping 13 matching lines @@
     return new Notification("analysis.implemented", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisImplementedParams) {
       return file == other.file &&
-          _listEqual(classes, other.classes, (ImplementedClass a, ImplementedClass b) => a == b) &&
-          _listEqual(members, other.members, (ImplementedMember a, ImplementedMember b) => a == b);
+          listEqual(classes, other.classes, (ImplementedClass a, ImplementedClass b) => a == b) &&
+          listEqual(members, other.members, (ImplementedMember a, ImplementedMember b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, classes.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, members.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, classes.hashCode);
+    hash = JenkinsSmiHash.combine(hash, members.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.invalidate params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "delta": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisInvalidateParams implements HasToJson {
   String _file;
 
   int _offset;
 
   int _length;
 
   int _delta;
 
@@ skipping 60 matching lines @@
     this.delta = delta;
   }
 
   factory AnalysisInvalidateParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       int delta;
       if (json.containsKey("delta")) {
-        delta = jsonDecoder._decodeInt(jsonPath + ".delta", json["delta"]);
+        delta = jsonDecoder.decodeInt(jsonPath + ".delta", json["delta"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "delta");
       }
       return new AnalysisInvalidateParams(file, offset, length, delta);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.invalidate params", json);
     }
   }
 
   factory AnalysisInvalidateParams.fromNotification(Notification notification) {
@@ skipping 24 matching lines @@
           offset == other.offset &&
           length == other.length &&
           delta == other.delta;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, delta.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, delta.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
  *   "regions": List<NavigationRegion>
  *   "targets": List<NavigationTarget>
  *   "files": List<FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisNavigationParams implements HasToJson {
   String _file;
 
   List<NavigationRegion> _regions;
 
   List<NavigationTarget> _targets;
 
   List<String> _files;
 
@@ skipping 72 matching lines @@
     this.files = files;
   }
 
   factory AnalysisNavigationParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<NavigationRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       List<NavigationTarget> targets;
       if (json.containsKey("targets")) {
-        targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
+        targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "targets");
       }
       List<String> files;
       if (json.containsKey("files")) {
-        files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
+        files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisNavigationParams(file, regions, targets, files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params", json);
     }
   }
 
   factory AnalysisNavigationParams.fromNotification(Notification notification) {
@@ skipping 14 matching lines @@
     return new Notification("analysis.navigation", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisNavigationParams) {
       return file == other.file &&
-          _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b) &&
-          _listEqual(targets, other.targets, (NavigationTarget a, NavigationTarget b) => a == b) &&
-          _listEqual(files, other.files, (String a, String b) => a == b);
+          listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b) &&
+          listEqual(targets, other.targets, (NavigationTarget a, NavigationTarget b) => a == b) &&
+          listEqual(files, other.files, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, targets.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, files.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, regions.hashCode);
+    hash = JenkinsSmiHash.combine(hash, targets.hashCode);
+    hash = JenkinsSmiHash.combine(hash, files.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.occurrences params
  *
  * {
  *   "file": FilePath
  *   "occurrences": List<Occurrences>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisOccurrencesParams implements HasToJson {
   String _file;
 
   List<Occurrences> _occurrences;
 
   /**
    * The file in which the references occur.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.occurrences = occurrences;
   }
 
   factory AnalysisOccurrencesParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<Occurrences> occurrences;
       if (json.containsKey("occurrences")) {
-        occurrences = jsonDecoder._decodeList(jsonPath + ".occurrences", json["occurrences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDecoder, jsonPath, json));
+        occurrences = jsonDecoder.decodeList(jsonPath + ".occurrences", json["occurrences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "occurrences");
       }
       return new AnalysisOccurrencesParams(file, occurrences);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params", json);
     }
   }
 
   factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
@@ skipping 12 matching lines @@
     return new Notification("analysis.occurrences", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisOccurrencesParams) {
       return file == other.file &&
-          _listEqual(occurrences, other.occurrences, (Occurrences a, Occurrences b) => a == b);
+          listEqual(occurrences, other.occurrences, (Occurrences a, Occurrences b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, occurrences.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, occurrences.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.outline params
  *
  * {
  *   "file": FilePath
  *   "kind": FileKind
  *   "libraryName": optional String
  *   "outline": Outline
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisOutlineParams implements HasToJson {
   String _file;
 
   FileKind _kind;
 
   String _libraryName;
 
   Outline _outline;
 
@@ skipping 63 matching lines @@
     this.outline = outline;
   }
 
   factory AnalysisOutlineParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       FileKind kind;
       if (json.containsKey("kind")) {
         kind = new FileKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       String libraryName;
       if (json.containsKey("libraryName")) {
-        libraryName = jsonDecoder._decodeString(jsonPath + ".libraryName", json["libraryName"]);
+        libraryName = jsonDecoder.decodeString(jsonPath + ".libraryName", json["libraryName"]);
       }
       Outline outline;
       if (json.containsKey("outline")) {
         outline = new Outline.fromJson(jsonDecoder, jsonPath + ".outline", json["outline"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "outline");
       }
       return new AnalysisOutlineParams(file, kind, outline, libraryName: libraryName);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.outline params", json);
@@ skipping 30 matching lines @@
           kind == other.kind &&
           libraryName == other.libraryName &&
           outline == other.outline;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, libraryName.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, outline.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, libraryName.hashCode);
+    hash = JenkinsSmiHash.combine(hash, outline.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.overrides params
  *
  * {
  *   "file": FilePath
  *   "overrides": List<Override>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisOverridesParams implements HasToJson {
   String _file;
 
   List<Override> _overrides;
 
   /**
    * The file with which the overrides are associated.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.overrides = overrides;
   }
 
   factory AnalysisOverridesParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<Override> overrides;
       if (json.containsKey("overrides")) {
-        overrides = jsonDecoder._decodeList(jsonPath + ".overrides", json["overrides"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, jsonPath, json));
+        overrides = jsonDecoder.decodeList(jsonPath + ".overrides", json["overrides"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "overrides");
       }
       return new AnalysisOverridesParams(file, overrides);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params", json);
     }
   }
 
   factory AnalysisOverridesParams.fromNotification(Notification notification) {
@@ skipping 12 matching lines @@
     return new Notification("analysis.overrides", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisOverridesParams) {
       return file == other.file &&
-          _listEqual(overrides, other.overrides, (Override a, Override b) => a == b);
+          listEqual(overrides, other.overrides, (Override a, Override b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, overrides.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, overrides.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * completion.getSuggestions params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class CompletionGetSuggestionsParams implements HasToJson {
   String _file;
 
   int _offset;
 
   /**
    * The file containing the point at which suggestions are to be made.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.offset = offset;
   }
 
   factory CompletionGetSuggestionsParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new CompletionGetSuggestionsParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params", json);
     }
   }
 
   factory CompletionGetSuggestionsParams.fromRequest(Request request) {
@@ skipping 20 matching lines @@
     if (other is CompletionGetSuggestionsParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * completion.getSuggestions result
  *
  * {
  *   "id": CompletionId
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class CompletionGetSuggestionsResult implements HasToJson {
   String _id;
 
   /**
    * The identifier used to associate results with this completion request.
    */
   String get id => _id;
 
   /**
    * The identifier used to associate results with this completion request.
    */
   void set id(String value) {
     assert(value != null);
     this._id = value;
   }
 
   CompletionGetSuggestionsResult(String id) {
     this.id = 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"]);
+        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", json);
     }
   }
 
   factory CompletionGetSuggestionsResult.fromResponse(Response response) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is CompletionGetSuggestionsResult) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * completion.results params
  *
  * {
  *   "id": CompletionId
  *   "replacementOffset": int
  *   "replacementLength": int
  *   "results": List<CompletionSuggestion>
  *   "isLast": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class CompletionResultsParams implements HasToJson {
   String _id;
 
   int _replacementOffset;
 
   int _replacementLength;
 
   List<CompletionSuggestion> _results;
 
@@ skipping 92 matching lines @@
     this.isLast = isLast;
   }
 
   factory CompletionResultsParams.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       int replacementOffset;
       if (json.containsKey("replacementOffset")) {
-        replacementOffset = jsonDecoder._decodeInt(jsonPath + ".replacementOffset", json["replacementOffset"]);
+        replacementOffset = jsonDecoder.decodeInt(jsonPath + ".replacementOffset", json["replacementOffset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "replacementOffset");
       }
       int replacementLength;
       if (json.containsKey("replacementLength")) {
-        replacementLength = jsonDecoder._decodeInt(jsonPath + ".replacementLength", json["replacementLength"]);
+        replacementLength = jsonDecoder.decodeInt(jsonPath + ".replacementLength", json["replacementLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "replacementLength");
       }
       List<CompletionSuggestion> results;
       if (json.containsKey("results")) {
-        results = jsonDecoder._decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder, jsonPath, json));
+        results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "results");
       }
       bool isLast;
       if (json.containsKey("isLast")) {
-        isLast = jsonDecoder._decodeBool(jsonPath + ".isLast", json["isLast"]);
+        isLast = jsonDecoder.decodeBool(jsonPath + ".isLast", json["isLast"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isLast");
       }
       return new CompletionResultsParams(id, replacementOffset, replacementLength, results, isLast);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.results params", json);
     }
   }
 
   factory CompletionResultsParams.fromNotification(Notification notification) {
@@ skipping 17 matching lines @@
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is CompletionResultsParams) {
       return id == other.id &&
           replacementOffset == other.replacementOffset &&
           replacementLength == other.replacementLength &&
-          _listEqual(results, other.results, (CompletionSuggestion a, CompletionSuggestion b) => a == b) &&
+          listEqual(results, other.results, (CompletionSuggestion a, CompletionSuggestion b) => a == b) &&
           isLast == other.isLast;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, replacementOffset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, replacementLength.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, results.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, isLast.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    hash = JenkinsSmiHash.combine(hash, replacementOffset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, replacementLength.hashCode);
+    hash = JenkinsSmiHash.combine(hash, results.hashCode);
+    hash = JenkinsSmiHash.combine(hash, isLast.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findElementReferences params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "includePotential": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindElementReferencesParams implements HasToJson {
   String _file;
 
   int _offset;
 
   bool _includePotential;
 
   /**
    * The file containing the declaration of or reference to the element used to
@@ skipping 44 matching lines @@
     this.includePotential = includePotential;
   }
 
   factory SearchFindElementReferencesParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       bool includePotential;
       if (json.containsKey("includePotential")) {
-        includePotential = jsonDecoder._decodeBool(jsonPath + ".includePotential", json["includePotential"]);
+        includePotential = jsonDecoder.decodeBool(jsonPath + ".includePotential", json["includePotential"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "includePotential");
       }
       return new SearchFindElementReferencesParams(file, offset, includePotential);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences params", json);
     }
   }
 
   factory SearchFindElementReferencesParams.fromRequest(Request request) {
@@ skipping 22 matching lines @@
       return file == other.file &&
           offset == other.offset &&
           includePotential == other.includePotential;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, includePotential.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, includePotential.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findElementReferences result
  *
  * {
  *   "id": optional SearchId
  *   "element": optional Element
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindElementReferencesResult implements HasToJson {
   String _id;
 
   Element _element;
 
   /**
    * The identifier used to associate results with this search request.
    *
    * If no element was found at the given location, this field will be absent,
@@ skipping 34 matching lines @@
     this.element = element;
   }
 
   factory SearchFindElementReferencesResult.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       }
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       }
       return new SearchFindElementReferencesResult(id: id, element: element);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result", json);
     }
   }
@@ skipping 26 matching lines @@
     if (other is SearchFindElementReferencesResult) {
       return id == other.id &&
           element == other.element;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, element.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    hash = JenkinsSmiHash.combine(hash, element.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findMemberDeclarations params
  *
  * {
  *   "name": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindMemberDeclarationsParams implements HasToJson {
   String _name;
 
   /**
    * The name of the declarations to be found.
    */
   String get name => _name;
 
   /**
    * The name of the declarations to be found.
    */
   void set name(String value) {
     assert(value != null);
     this._name = value;
   }
 
   SearchFindMemberDeclarationsParams(String name) {
     this.name = 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"]);
+        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", json);
     }
   }
 
   factory SearchFindMemberDeclarationsParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is SearchFindMemberDeclarationsParams) {
       return name == other.name;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, name.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, name.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findMemberDeclarations result
  *
  * {
  *   "id": SearchId
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindMemberDeclarationsResult implements HasToJson {
   String _id;
 
   /**
    * The identifier used to associate results with this search request.
    */
   String get id => _id;
 
   /**
    * The identifier used to associate results with this search request.
    */
   void set id(String value) {
     assert(value != null);
     this._id = value;
   }
 
   SearchFindMemberDeclarationsResult(String id) {
     this.id = 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"]);
+        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", json);
     }
   }
 
   factory SearchFindMemberDeclarationsResult.fromResponse(Response response) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is SearchFindMemberDeclarationsResult) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findMemberReferences params
  *
  * {
  *   "name": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindMemberReferencesParams implements HasToJson {
   String _name;
 
   /**
    * The name of the references to be found.
    */
   String get name => _name;
 
   /**
    * The name of the references to be found.
    */
   void set name(String value) {
     assert(value != null);
     this._name = value;
   }
 
   SearchFindMemberReferencesParams(String name) {
     this.name = 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"]);
+        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", json);
     }
   }
 
   factory SearchFindMemberReferencesParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is SearchFindMemberReferencesParams) {
       return name == other.name;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, name.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, name.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findMemberReferences result
  *
  * {
  *   "id": SearchId
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindMemberReferencesResult implements HasToJson {
   String _id;
 
   /**
    * The identifier used to associate results with this search request.
    */
   String get id => _id;
 
   /**
    * The identifier used to associate results with this search request.
    */
   void set id(String value) {
     assert(value != null);
     this._id = value;
   }
 
   SearchFindMemberReferencesResult(String id) {
     this.id = 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"]);
+        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", json);
     }
   }
 
   factory SearchFindMemberReferencesResult.fromResponse(Response response) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is SearchFindMemberReferencesResult) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findTopLevelDeclarations params
  *
  * {
  *   "pattern": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindTopLevelDeclarationsParams implements HasToJson {
   String _pattern;
 
   /**
    * The regular expression used to match the names of the declarations to be
    * found.
    */
   String get pattern => _pattern;
 
@@ skipping 10 matching lines @@
     this.pattern = 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"]);
+        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", json);
     }
   }
 
   factory SearchFindTopLevelDeclarationsParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is SearchFindTopLevelDeclarationsParams) {
       return pattern == other.pattern;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, pattern.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, pattern.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findTopLevelDeclarations result
  *
  * {
  *   "id": SearchId
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchFindTopLevelDeclarationsResult implements HasToJson {
   String _id;
 
   /**
    * The identifier used to associate results with this search request.
    */
   String get id => _id;
 
   /**
    * The identifier used to associate results with this search request.
    */
   void set id(String value) {
     assert(value != null);
     this._id = value;
   }
 
   SearchFindTopLevelDeclarationsResult(String id) {
     this.id = 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"]);
+        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", json);
     }
   }
 
   factory SearchFindTopLevelDeclarationsResult.fromResponse(Response response) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is SearchFindTopLevelDeclarationsResult) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.getTypeHierarchy params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "superOnly": optional bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchGetTypeHierarchyParams implements HasToJson {
   String _file;
 
   int _offset;
 
   bool _superOnly;
 
   /**
    * The file containing the declaration or reference to the type for which a
@@ skipping 43 matching lines @@
     this.superOnly = superOnly;
   }
 
   factory SearchGetTypeHierarchyParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       bool superOnly;
       if (json.containsKey("superOnly")) {
-        superOnly = jsonDecoder._decodeBool(jsonPath + ".superOnly", json["superOnly"]);
+        superOnly = jsonDecoder.decodeBool(jsonPath + ".superOnly", json["superOnly"]);
       }
       return new SearchGetTypeHierarchyParams(file, offset, superOnly: superOnly);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy params", json);
     }
   }
 
   factory SearchGetTypeHierarchyParams.fromRequest(Request request) {
     return new SearchGetTypeHierarchyParams.fromJson(
         new RequestDecoder(request), "params", request._params);
@@ skipping 22 matching lines @@
       return file == other.file &&
           offset == other.offset &&
           superOnly == other.superOnly;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, superOnly.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, superOnly.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.getTypeHierarchy result
  *
  * {
  *   "hierarchyItems": optional List<TypeHierarchyItem>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchGetTypeHierarchyResult implements HasToJson {
   List<TypeHierarchyItem> _hierarchyItems;
 
   /**
    * 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.
@@ skipping 23 matching lines @@
     this.hierarchyItems = hierarchyItems;
   }
 
   factory SearchGetTypeHierarchyResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<TypeHierarchyItem> hierarchyItems;
       if (json.containsKey("hierarchyItems")) {
-        hierarchyItems = jsonDecoder._decodeList(jsonPath + ".hierarchyItems", json["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.fromJson(jsonDecoder, jsonPath, json));
+        hierarchyItems = jsonDecoder.decodeList(jsonPath + ".hierarchyItems", json["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.fromJson(jsonDecoder, jsonPath, json));
       }
       return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result", json);
     }
   }
 
   factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
     return new SearchGetTypeHierarchyResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
@@ skipping 10 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchGetTypeHierarchyResult) {
-      return _listEqual(hierarchyItems, other.hierarchyItems, (TypeHierarchyItem a, TypeHierarchyItem b) => a == b);
+      return listEqual(hierarchyItems, other.hierarchyItems, (TypeHierarchyItem a, TypeHierarchyItem b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, hierarchyItems.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, hierarchyItems.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.results params
  *
  * {
  *   "id": SearchId
  *   "results": List<SearchResult>
  *   "isLast": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchResultsParams implements HasToJson {
   String _id;
 
   List<SearchResult> _results;
 
   bool _isLast;
 
   /**
    * The id associated with the search.
@@ skipping 42 matching lines @@
     this.isLast = isLast;
   }
 
   factory SearchResultsParams.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       List<SearchResult> results;
       if (json.containsKey("results")) {
-        results = jsonDecoder._decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonPath, json));
+        results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "results");
       }
       bool isLast;
       if (json.containsKey("isLast")) {
-        isLast = jsonDecoder._decodeBool(jsonPath + ".isLast", json["isLast"]);
+        isLast = jsonDecoder.decodeBool(jsonPath + ".isLast", json["isLast"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isLast");
       }
       return new SearchResultsParams(id, results, isLast);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.results params", json);
     }
   }
 
   factory SearchResultsParams.fromNotification(Notification notification) {
@@ skipping 13 matching lines @@
     return new Notification("search.results", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchResultsParams) {
       return id == other.id &&
-          _listEqual(results, other.results, (SearchResult a, SearchResult b) => a == b) &&
+          listEqual(results, other.results, (SearchResult a, SearchResult b) => a == b) &&
           isLast == other.isLast;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, results.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, isLast.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    hash = JenkinsSmiHash.combine(hash, results.hashCode);
+    hash = JenkinsSmiHash.combine(hash, isLast.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.format params
  *
  * {
  *   "file": FilePath
  *   "selectionOffset": int
  *   "selectionLength": int
  *   "lineLength": optional int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditFormatParams implements HasToJson {
   String _file;
 
   int _selectionOffset;
 
   int _selectionLength;
 
   int _lineLength;
 
@@ skipping 55 matching lines @@
     this.lineLength = lineLength;
   }
 
   factory EditFormatParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int selectionOffset;
       if (json.containsKey("selectionOffset")) {
-        selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
+        selectionOffset = jsonDecoder.decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionOffset");
       }
       int selectionLength;
       if (json.containsKey("selectionLength")) {
-        selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
+        selectionLength = jsonDecoder.decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionLength");
       }
       int lineLength;
       if (json.containsKey("lineLength")) {
-        lineLength = jsonDecoder._decodeInt(jsonPath + ".lineLength", json["lineLength"]);
+        lineLength = jsonDecoder.decodeInt(jsonPath + ".lineLength", json["lineLength"]);
       }
       return new EditFormatParams(file, selectionOffset, selectionLength, lineLength: lineLength);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.format params", json);
     }
   }
 
   factory EditFormatParams.fromRequest(Request request) {
     return new EditFormatParams.fromJson(
         new RequestDecoder(request), "params", request._params);
@@ skipping 24 matching lines @@
           selectionOffset == other.selectionOffset &&
           selectionLength == other.selectionLength &&
           lineLength == other.lineLength;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, lineLength.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selectionLength.hashCode);
+    hash = JenkinsSmiHash.combine(hash, lineLength.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.format result
  *
  * {
  *   "edits": List<SourceEdit>
  *   "selectionOffset": int
  *   "selectionLength": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditFormatResult implements HasToJson {
   List<SourceEdit> _edits;
 
   int _selectionOffset;
 
   int _selectionLength;
 
   /**
    * The edit(s) to be applied in order to format the code. The list will be
@@ skipping 42 matching lines @@
     this.selectionLength = selectionLength;
   }
 
   factory EditFormatResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       int selectionOffset;
       if (json.containsKey("selectionOffset")) {
-        selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
+        selectionOffset = jsonDecoder.decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionOffset");
       }
       int selectionLength;
       if (json.containsKey("selectionLength")) {
-        selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
+        selectionLength = jsonDecoder.decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionLength");
       }
       return new EditFormatResult(edits, selectionOffset, selectionLength);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.format result", json);
     }
   }
 
   factory EditFormatResult.fromResponse(Response response) {
@@ skipping 12 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditFormatResult) {
-      return _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b) &&
+      return listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b) &&
           selectionOffset == other.selectionOffset &&
           selectionLength == other.selectionLength;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, edits.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selectionLength.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getAssists params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetAssistsParams implements HasToJson {
   String _file;
 
   int _offset;
 
   int _length;
 
   /**
    * The file containing the code for which assists are being requested.
@@ skipping 40 matching lines @@
     this.length = length;
   }
 
   factory EditGetAssistsParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new EditGetAssistsParams(file, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists params", json);
     }
   }
 
   factory EditGetAssistsParams.fromRequest(Request request) {
@@ skipping 22 matching lines @@
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getAssists result
  *
  * {
  *   "assists": List<SourceChange>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetAssistsResult implements HasToJson {
   List<SourceChange> _assists;
 
   /**
    * The assists that are available at the given location.
    */
   List<SourceChange> get assists => _assists;
 
   /**
    * The assists that are available at the given location.
    */
   void set assists(List<SourceChange> value) {
     assert(value != null);
     this._assists = value;
   }
 
   EditGetAssistsResult(List<SourceChange> assists) {
     this.assists = 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));
+        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", json);
     }
   }
 
   factory EditGetAssistsResult.fromResponse(Response response) {
@@ skipping 10 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetAssistsResult) {
-      return _listEqual(assists, other.assists, (SourceChange a, SourceChange b) => a == b);
+      return listEqual(assists, other.assists, (SourceChange a, SourceChange b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, assists.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, assists.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getAvailableRefactorings params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetAvailableRefactoringsParams implements HasToJson {
   String _file;
 
   int _offset;
 
   int _length;
 
   /**
    * The file containing the code on which the refactoring would be based.
@@ skipping 40 matching lines @@
     this.length = length;
   }
 
   factory EditGetAvailableRefactoringsParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new EditGetAvailableRefactoringsParams(file, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params", json);
     }
   }
 
   factory EditGetAvailableRefactoringsParams.fromRequest(Request request) {
@@ skipping 22 matching lines @@
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getAvailableRefactorings result
  *
  * {
  *   "kinds": List<RefactoringKind>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetAvailableRefactoringsResult implements HasToJson {
   List<RefactoringKind> _kinds;
 
   /**
    * The kinds of refactorings that are valid for the given selection.
    */
   List<RefactoringKind> get kinds => _kinds;
 
   /**
    * The kinds of refactorings that are valid for the given selection.
    */
   void set kinds(List<RefactoringKind> value) {
     assert(value != null);
     this._kinds = value;
   }
 
   EditGetAvailableRefactoringsResult(List<RefactoringKind> kinds) {
     this.kinds = 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));
+        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", json);
     }
   }
 
   factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
@@ skipping 10 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetAvailableRefactoringsResult) {
-      return _listEqual(kinds, other.kinds, (RefactoringKind a, RefactoringKind b) => a == b);
+      return listEqual(kinds, other.kinds, (RefactoringKind a, RefactoringKind b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, kinds.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, kinds.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getFixes params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetFixesParams implements HasToJson {
   String _file;
 
   int _offset;
 
   /**
    * The file containing the errors for which fixes are being requested.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.offset = offset;
   }
 
   factory EditGetFixesParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new EditGetFixesParams(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes params", json);
     }
   }
 
   factory EditGetFixesParams.fromRequest(Request request) {
@@ skipping 20 matching lines @@
     if (other is EditGetFixesParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getFixes result
  *
  * {
  *   "fixes": List<AnalysisErrorFixes>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetFixesResult implements HasToJson {
   List<AnalysisErrorFixes> _fixes;
 
   /**
    * The fixes that are available for the errors at the given offset.
    */
   List<AnalysisErrorFixes> get fixes => _fixes;
 
   /**
    * The fixes that are available for the errors at the given offset.
    */
   void set fixes(List<AnalysisErrorFixes> value) {
     assert(value != null);
     this._fixes = value;
   }
 
   EditGetFixesResult(List<AnalysisErrorFixes> fixes) {
     this.fixes = fixes;
   }
 
   factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<AnalysisErrorFixes> fixes;
       if (json.containsKey("fixes")) {
-        fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPath, json));
+        fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new EditGetFixesResult(fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result", json);
     }
   }
 
   factory EditGetFixesResult.fromResponse(Response response) {
@@ skipping 10 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetFixesResult) {
-      return _listEqual(fixes, other.fixes, (AnalysisErrorFixes a, AnalysisErrorFixes b) => a == b);
+      return listEqual(fixes, other.fixes, (AnalysisErrorFixes a, AnalysisErrorFixes b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, fixes.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getRefactoring params
  *
  * {
  *   "kind": RefactoringKind
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "validateOnly": bool
  *   "options": optional RefactoringOptions
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetRefactoringParams implements HasToJson {
   RefactoringKind _kind;
 
   String _file;
 
   int _offset;
 
   int _length;
 
@@ skipping 103 matching lines @@
     }
     if (json is Map) {
       RefactoringKind kind;
       if (json.containsKey("kind")) {
         kind = new RefactoringKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       String file;
       if (json.containsKey("file")) {
-        file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       bool validateOnly;
       if (json.containsKey("validateOnly")) {
-        validateOnly = jsonDecoder._decodeBool(jsonPath + ".validateOnly", json["validateOnly"]);
+        validateOnly = jsonDecoder.decodeBool(jsonPath + ".validateOnly", json["validateOnly"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "validateOnly");
       }
       RefactoringOptions options;
       if (json.containsKey("options")) {
         options = new RefactoringOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"], kind);
       }
       return new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params", json);
@@ skipping 36 matching lines @@
           length == other.length &&
           validateOnly == other.validateOnly &&
           options == other.options;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, validateOnly.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, options.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, validateOnly.hashCode);
+    hash = JenkinsSmiHash.combine(hash, options.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getRefactoring result
  *
  * {
  *   "initialProblems": List<RefactoringProblem>
  *   "optionsProblems": List<RefactoringProblem>
  *   "finalProblems": List<RefactoringProblem>
  *   "feedback": optional RefactoringFeedback
  *   "change": optional SourceChange
  *   "potentialEdits": optional List<String>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditGetRefactoringResult implements HasToJson {
   List<RefactoringProblem> _initialProblems;
 
   List<RefactoringProblem> _optionsProblems;
 
   List<RefactoringProblem> _finalProblems;
 
   RefactoringFeedback _feedback;
 
@@ skipping 119 matching lines @@
     this.potentialEdits = potentialEdits;
   }
 
   factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<RefactoringProblem> initialProblems;
       if (json.containsKey("initialProblems")) {
-        initialProblems = jsonDecoder._decodeList(jsonPath + ".initialProblems", json["initialProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
+        initialProblems = jsonDecoder.decodeList(jsonPath + ".initialProblems", json["initialProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "initialProblems");
       }
       List<RefactoringProblem> optionsProblems;
       if (json.containsKey("optionsProblems")) {
-        optionsProblems = jsonDecoder._decodeList(jsonPath + ".optionsProblems", json["optionsProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
+        optionsProblems = jsonDecoder.decodeList(jsonPath + ".optionsProblems", json["optionsProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "optionsProblems");
       }
       List<RefactoringProblem> finalProblems;
       if (json.containsKey("finalProblems")) {
-        finalProblems = jsonDecoder._decodeList(jsonPath + ".finalProblems", json["finalProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
+        finalProblems = jsonDecoder.decodeList(jsonPath + ".finalProblems", json["finalProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "finalProblems");
       }
       RefactoringFeedback feedback;
       if (json.containsKey("feedback")) {
         feedback = new RefactoringFeedback.fromJson(jsonDecoder, jsonPath + ".feedback", json["feedback"], json);
       }
       SourceChange change;
       if (json.containsKey("change")) {
         change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", json["change"]);
       }
       List<String> potentialEdits;
       if (json.containsKey("potentialEdits")) {
-        potentialEdits = jsonDecoder._decodeList(jsonPath + ".potentialEdits", json["potentialEdits"], jsonDecoder._decodeString);
+        potentialEdits = jsonDecoder.decodeList(jsonPath + ".potentialEdits", json["potentialEdits"], jsonDecoder.decodeString);
       }
       return new EditGetRefactoringResult(initialProblems, optionsProblems, finalProblems, feedback: feedback, change: change, potentialEdits: potentialEdits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result", json);
     }
   }
 
   factory EditGetRefactoringResult.fromResponse(Response response) {
     return new EditGetRefactoringResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
@@ skipping 19 matching lines @@
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetRefactoringResult) {
-      return _listEqual(initialProblems, other.initialProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
-          _listEqual(optionsProblems, other.optionsProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
-          _listEqual(finalProblems, other.finalProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
+      return listEqual(initialProblems, other.initialProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
+          listEqual(optionsProblems, other.optionsProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
+          listEqual(finalProblems, other.finalProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
           feedback == other.feedback &&
           change == other.change &&
-          _listEqual(potentialEdits, other.potentialEdits, (String a, String b) => a == b);
+          listEqual(potentialEdits, other.potentialEdits, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, initialProblems.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, optionsProblems.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, finalProblems.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, feedback.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, change.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, potentialEdits.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, initialProblems.hashCode);
+    hash = JenkinsSmiHash.combine(hash, optionsProblems.hashCode);
+    hash = JenkinsSmiHash.combine(hash, finalProblems.hashCode);
+    hash = JenkinsSmiHash.combine(hash, feedback.hashCode);
+    hash = JenkinsSmiHash.combine(hash, change.hashCode);
+    hash = JenkinsSmiHash.combine(hash, potentialEdits.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.sortMembers params
  *
  * {
  *   "file": FilePath
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditSortMembersParams implements HasToJson {
   String _file;
 
   /**
    * The Dart file to sort.
    */
   String get file => _file;
 
   /**
    * The Dart file to sort.
    */
   void set file(String value) {
     assert(value != null);
     this._file = value;
   }
 
   EditSortMembersParams(String file) {
     this.file = file;
   }
 
   factory EditSortMembersParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       return new EditSortMembersParams(file);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers params", json);
     }
   }
 
   factory EditSortMembersParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is EditSortMembersParams) {
       return file == other.file;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.sortMembers result
  *
  * {
  *   "edit": SourceFileEdit
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditSortMembersResult implements HasToJson {
   SourceFileEdit _edit;
 
   /**
    * The file edit that is to be applied to the given file to effect the
    * sorting.
    */
   SourceFileEdit get edit => _edit;
 
@@ skipping 49 matching lines @@
   bool operator==(other) {
     if (other is EditSortMembersResult) {
       return edit == other.edit;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, edit.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, edit.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.organizeDirectives params
  *
  * {
  *   "file": FilePath
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditOrganizeDirectivesParams implements HasToJson {
   String _file;
 
   /**
    * The Dart file to organize directives in.
    */
   String get file => _file;
 
   /**
    * The Dart file to organize directives in.
    */
   void set file(String value) {
     assert(value != null);
     this._file = value;
   }
 
   EditOrganizeDirectivesParams(String file) {
     this.file = file;
   }
 
   factory EditOrganizeDirectivesParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       return new EditOrganizeDirectivesParams(file);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.organizeDirectives params", json);
     }
   }
 
   factory EditOrganizeDirectivesParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is EditOrganizeDirectivesParams) {
       return file == other.file;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.organizeDirectives result
  *
  * {
  *   "edit": SourceFileEdit
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class EditOrganizeDirectivesResult implements HasToJson {
   SourceFileEdit _edit;
 
   /**
    * The file edit that is to be applied to the given file to effect the
    * organizing.
    */
   SourceFileEdit get edit => _edit;
 
@@ skipping 49 matching lines @@
   bool operator==(other) {
     if (other is EditOrganizeDirectivesResult) {
       return edit == other.edit;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, edit.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, edit.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * execution.createContext params
  *
  * {
  *   "contextRoot": FilePath
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionCreateContextParams implements HasToJson {
   String _contextRoot;
 
   /**
    * The path of the Dart or HTML file that will be launched, or the path of
    * the directory containing the file.
    */
   String get contextRoot => _contextRoot;
 
@@ skipping 10 matching lines @@
     this.contextRoot = contextRoot;
   }
 
   factory ExecutionCreateContextParams.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"]);
+        contextRoot = jsonDecoder.decodeString(jsonPath + ".contextRoot", json["contextRoot"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "contextRoot");
       }
       return new ExecutionCreateContextParams(contextRoot);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.createContext params", json);
     }
   }
 
   factory ExecutionCreateContextParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is ExecutionCreateContextParams) {
       return contextRoot == other.contextRoot;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, contextRoot.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, contextRoot.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * execution.createContext result
  *
  * {
  *   "id": ExecutionContextId
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionCreateContextResult implements HasToJson {
   String _id;
 
   /**
    * The identifier used to refer to the execution context that was created.
    */
   String get id => _id;
 
   /**
    * The identifier used to refer to the execution context that was created.
    */
   void set id(String value) {
     assert(value != null);
     this._id = value;
   }
 
   ExecutionCreateContextResult(String id) {
     this.id = id;
   }
 
   factory ExecutionCreateContextResult.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new ExecutionCreateContextResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.createContext result", json);
     }
   }
 
   factory ExecutionCreateContextResult.fromResponse(Response response) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is ExecutionCreateContextResult) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * execution.deleteContext params
  *
  * {
  *   "id": ExecutionContextId
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionDeleteContextParams implements HasToJson {
   String _id;
 
   /**
    * The identifier of the execution context that is to be deleted.
    */
   String get id => _id;
 
   /**
    * The identifier of the execution context that is to be deleted.
    */
   void set id(String value) {
     assert(value != null);
     this._id = value;
   }
 
   ExecutionDeleteContextParams(String id) {
     this.id = id;
   }
 
   factory ExecutionDeleteContextParams.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new ExecutionDeleteContextParams(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.deleteContext params", json);
     }
   }
 
   factory ExecutionDeleteContextParams.fromRequest(Request request) {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is ExecutionDeleteContextParams) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * execution.deleteContext result
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionDeleteContextResult {
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
   bool operator==(other) {
     if (other is ExecutionDeleteContextResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 479954425;
   }
 }
 
 /**
  * execution.mapUri params
  *
  * {
  *   "id": ExecutionContextId
  *   "file": optional FilePath
  *   "uri": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionMapUriParams implements HasToJson {
   String _id;
 
   String _file;
 
   String _uri;
 
   /**
    * The identifier of the execution context in which the URI is to be mapped.
@@ skipping 38 matching lines @@
     this.uri = uri;
   }
 
   factory ExecutionMapUriParams.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       String file;
       if (json.containsKey("file")) {
-        file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       }
       String uri;
       if (json.containsKey("uri")) {
-        uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
+        uri = jsonDecoder.decodeString(jsonPath + ".uri", json["uri"]);
       }
       return new ExecutionMapUriParams(id, file: file, uri: uri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.mapUri params", json);
     }
   }
 
   factory ExecutionMapUriParams.fromRequest(Request request) {
     return new ExecutionMapUriParams.fromJson(
         new RequestDecoder(request), "params", request._params);
@@ skipping 24 matching lines @@
       return id == other.id &&
           file == other.file &&
           uri == other.uri;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, uri.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * execution.mapUri result
  *
  * {
  *   "file": optional FilePath
  *   "uri": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionMapUriResult implements HasToJson {
   String _file;
 
   String _uri;
 
   /**
    * The file to which the URI was mapped. This field is omitted if the uri
    * field was not given in the request.
    */
@@ skipping 26 matching lines @@
     this.uri = uri;
   }
 
   factory ExecutionMapUriResult.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       }
       String uri;
       if (json.containsKey("uri")) {
-        uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
+        uri = jsonDecoder.decodeString(jsonPath + ".uri", json["uri"]);
       }
       return new ExecutionMapUriResult(file: file, uri: uri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.mapUri result", json);
     }
   }
 
   factory ExecutionMapUriResult.fromResponse(Response response) {
     return new ExecutionMapUriResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
@@ skipping 22 matching lines @@
     if (other is ExecutionMapUriResult) {
       return file == other.file &&
           uri == other.uri;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, uri.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * execution.setSubscriptions params
  *
  * {
  *   "subscriptions": List<ExecutionService>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionSetSubscriptionsParams implements HasToJson {
   List<ExecutionService> _subscriptions;
 
   /**
    * A list of the services being subscribed to.
    */
   List<ExecutionService> get subscriptions => _subscriptions;
 
   /**
    * A list of the services being subscribed to.
    */
   void set subscriptions(List<ExecutionService> value) {
     assert(value != null);
     this._subscriptions = value;
   }
 
   ExecutionSetSubscriptionsParams(List<ExecutionService> subscriptions) {
     this.subscriptions = subscriptions;
   }
 
   factory ExecutionSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<ExecutionService> subscriptions;
       if (json.containsKey("subscriptions")) {
-        subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJson(jsonDecoder, jsonPath, json));
+        subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new ExecutionSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params", json);
     }
   }
 
   factory ExecutionSetSubscriptionsParams.fromRequest(Request request) {
@@ skipping 10 matching lines @@
   Request toRequest(String id) {
     return new Request(id, "execution.setSubscriptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExecutionSetSubscriptionsParams) {
-      return _listEqual(subscriptions, other.subscriptions, (ExecutionService a, ExecutionService b) => a == b);
+      return listEqual(subscriptions, other.subscriptions, (ExecutionService a, ExecutionService b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, subscriptions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * execution.setSubscriptions result
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionSetSubscriptionsResult {
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
   bool operator==(other) {
     if (other is ExecutionSetSubscriptionsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 287678780;
   }
 }
 
 /**
  * execution.launchData params
  *
  * {
  *   "file": FilePath
  *   "kind": optional ExecutableKind
  *   "referencedFiles": optional List<FilePath>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionLaunchDataParams implements HasToJson {
   String _file;
 
   ExecutableKind _kind;
 
   List<String> _referencedFiles;
 
   /**
    * The file for which launch data is being provided. This will either be a
@@ skipping 44 matching lines @@
     this.referencedFiles = referencedFiles;
   }
 
   factory ExecutionLaunchDataParams.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       ExecutableKind kind;
       if (json.containsKey("kind")) {
         kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       }
       List<String> referencedFiles;
       if (json.containsKey("referencedFiles")) {
-        referencedFiles = jsonDecoder._decodeList(jsonPath + ".referencedFiles", json["referencedFiles"], jsonDecoder._decodeString);
+        referencedFiles = jsonDecoder.decodeList(jsonPath + ".referencedFiles", json["referencedFiles"], jsonDecoder.decodeString);
       }
       return new ExecutionLaunchDataParams(file, kind: kind, referencedFiles: referencedFiles);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "execution.launchData params", json);
     }
   }
 
   factory ExecutionLaunchDataParams.fromNotification(Notification notification) {
     return new ExecutionLaunchDataParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
@@ skipping 16 matching lines @@
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExecutionLaunchDataParams) {
       return file == other.file &&
           kind == other.kind &&
-          _listEqual(referencedFiles, other.referencedFiles, (String a, String b) => a == b);
+          listEqual(referencedFiles, other.referencedFiles, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, referencedFiles.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, referencedFiles.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AddContentOverlay
  *
  * {
  *   "type": "add"
  *   "content": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AddContentOverlay implements HasToJson {
   String _content;
 
   /**
    * The new content of the file.
    */
   String get content => _content;
 
   /**
@@ skipping 11 matching lines @@
   factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "add") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "add", json);
       }
       String content;
       if (json.containsKey("content")) {
-        content = jsonDecoder._decodeString(jsonPath + ".content", json["content"]);
+        content = jsonDecoder.decodeString(jsonPath + ".content", json["content"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "content");
       }
       return new AddContentOverlay(content);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AddContentOverlay", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 10 matching lines @@
   bool operator==(other) {
     if (other is AddContentOverlay) {
       return content == other.content;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, 704418402);
-    hash = _JenkinsSmiHash.combine(hash, content.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, 704418402);
+    hash = JenkinsSmiHash.combine(hash, content.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisError
  *
  * {
  *   "severity": AnalysisErrorSeverity
  *   "type": AnalysisErrorType
  *   "location": Location
  *   "message": String
  *   "correction": optional String
  *   "hasFix": optional bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisError implements HasToJson {
   AnalysisErrorSeverity _severity;
 
   AnalysisErrorType _type;
 
   Location _location;
 
   String _message;
 
@@ skipping 124 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "type");
       }
       Location location;
       if (json.containsKey("location")) {
         location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "location");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
+        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       String correction;
       if (json.containsKey("correction")) {
-        correction = jsonDecoder._decodeString(jsonPath + ".correction", json["correction"]);
+        correction = jsonDecoder.decodeString(jsonPath + ".correction", json["correction"]);
       }
       bool hasFix;
       if (json.containsKey("hasFix")) {
-        hasFix = jsonDecoder._decodeBool(jsonPath + ".hasFix", json["hasFix"]);
+        hasFix = jsonDecoder.decodeBool(jsonPath + ".hasFix", json["hasFix"]);
       }
       return new AnalysisError(severity, type, location, message, correction: correction, hasFix: hasFix);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AnalysisError", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["severity"] = severity.toJson();
@@ skipping 21 matching lines @@
           message == other.message &&
           correction == other.correction &&
           hasFix == other.hasFix;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, severity.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, type.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, location.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, message.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, correction.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, hasFix.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, severity.hashCode);
+    hash = JenkinsSmiHash.combine(hash, type.hashCode);
+    hash = JenkinsSmiHash.combine(hash, location.hashCode);
+    hash = JenkinsSmiHash.combine(hash, message.hashCode);
+    hash = JenkinsSmiHash.combine(hash, correction.hashCode);
+    hash = JenkinsSmiHash.combine(hash, hasFix.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisErrorFixes
  *
  * {
  *   "error": AnalysisError
  *   "fixes": List<SourceChange>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisErrorFixes implements HasToJson {
   AnalysisError _error;
 
   List<SourceChange> _fixes;
 
   /**
    * The error with which the fixes are associated.
    */
   AnalysisError get error => _error;
@@ skipping 34 matching lines @@
     }
     if (json is Map) {
       AnalysisError error;
       if (json.containsKey("error")) {
         error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", json["error"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "error");
       }
       List<SourceChange> fixes;
       if (json.containsKey("fixes")) {
-        fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
+        fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new AnalysisErrorFixes(error, fixes: fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["error"] = error.toJson();
     result["fixes"] = fixes.map((SourceChange value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisErrorFixes) {
       return error == other.error &&
-          _listEqual(fixes, other.fixes, (SourceChange a, SourceChange b) => a == b);
+          listEqual(fixes, other.fixes, (SourceChange a, SourceChange b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, error.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, error.hashCode);
+    hash = JenkinsSmiHash.combine(hash, fixes.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisErrorSeverity
  *
  * enum {
  *   INFO
  *   WARNING
  *   ERROR
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisErrorSeverity implements Enum {
   static const INFO = const AnalysisErrorSeverity._("INFO");
 
   static const WARNING = const AnalysisErrorSeverity._("WARNING");
 
   static const ERROR = const AnalysisErrorSeverity._("ERROR");
 
   /**
    * A list containing all of the enum values that are defined.
@@ skipping 39 matching lines @@
  * enum {
  *   CHECKED_MODE_COMPILE_TIME_ERROR
  *   COMPILE_TIME_ERROR
  *   HINT
  *   LINT
  *   STATIC_TYPE_WARNING
  *   STATIC_WARNING
  *   SYNTACTIC_ERROR
  *   TODO
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisErrorType implements Enum {
   static const CHECKED_MODE_COMPILE_TIME_ERROR = const AnalysisErrorType._("CHECKED_MODE_COMPILE_TIME_ERROR");
 
   static const COMPILE_TIME_ERROR = const AnalysisErrorType._("COMPILE_TIME_ERROR");
 
   static const HINT = const AnalysisErrorType._("HINT");
 
   static const LINT = const AnalysisErrorType._("LINT");
 
@@ skipping 59 matching lines @@
  * {
  *   "enableAsync": optional bool
  *   "enableDeferredLoading": optional bool
  *   "enableEnums": optional bool
  *   "enableNullAwareOperators": optional bool
  *   "enableSuperMixins": optional bool
  *   "generateDart2jsHints": optional bool
  *   "generateHints": optional bool
  *   "generateLints": optional bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisOptions implements HasToJson {
   bool _enableAsync;
 
   bool _enableDeferredLoading;
 
   bool _enableEnums;
 
   bool _enableNullAwareOperators;
 
@@ skipping 140 matching lines @@
     this.generateLints = generateLints;
   }
 
   factory AnalysisOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool enableAsync;
       if (json.containsKey("enableAsync")) {
-        enableAsync = jsonDecoder._decodeBool(jsonPath + ".enableAsync", json["enableAsync"]);
+        enableAsync = jsonDecoder.decodeBool(jsonPath + ".enableAsync", json["enableAsync"]);
       }
       bool enableDeferredLoading;
       if (json.containsKey("enableDeferredLoading")) {
-        enableDeferredLoading = jsonDecoder._decodeBool(jsonPath + ".enableDeferredLoading", json["enableDeferredLoading"]);
+        enableDeferredLoading = jsonDecoder.decodeBool(jsonPath + ".enableDeferredLoading", json["enableDeferredLoading"]);
       }
       bool enableEnums;
       if (json.containsKey("enableEnums")) {
-        enableEnums = jsonDecoder._decodeBool(jsonPath + ".enableEnums", json["enableEnums"]);
+        enableEnums = jsonDecoder.decodeBool(jsonPath + ".enableEnums", json["enableEnums"]);
       }
       bool enableNullAwareOperators;
       if (json.containsKey("enableNullAwareOperators")) {
-        enableNullAwareOperators = jsonDecoder._decodeBool(jsonPath + ".enableNullAwareOperators", json["enableNullAwareOperators"]);
+        enableNullAwareOperators = jsonDecoder.decodeBool(jsonPath + ".enableNullAwareOperators", json["enableNullAwareOperators"]);
       }
       bool enableSuperMixins;
       if (json.containsKey("enableSuperMixins")) {
-        enableSuperMixins = jsonDecoder._decodeBool(jsonPath + ".enableSuperMixins", json["enableSuperMixins"]);
+        enableSuperMixins = jsonDecoder.decodeBool(jsonPath + ".enableSuperMixins", json["enableSuperMixins"]);
       }
       bool generateDart2jsHints;
       if (json.containsKey("generateDart2jsHints")) {
-        generateDart2jsHints = jsonDecoder._decodeBool(jsonPath + ".generateDart2jsHints", json["generateDart2jsHints"]);
+        generateDart2jsHints = jsonDecoder.decodeBool(jsonPath + ".generateDart2jsHints", json["generateDart2jsHints"]);
       }
       bool generateHints;
       if (json.containsKey("generateHints")) {
-        generateHints = jsonDecoder._decodeBool(jsonPath + ".generateHints", json["generateHints"]);
+        generateHints = jsonDecoder.decodeBool(jsonPath + ".generateHints", json["generateHints"]);
       }
       bool generateLints;
       if (json.containsKey("generateLints")) {
-        generateLints = jsonDecoder._decodeBool(jsonPath + ".generateLints", json["generateLints"]);
+        generateLints = jsonDecoder.decodeBool(jsonPath + ".generateLints", json["generateLints"]);
       }
       return new AnalysisOptions(enableAsync: enableAsync, enableDeferredLoading: enableDeferredLoading, enableEnums: enableEnums, enableNullAwareOperators: enableNullAwareOperators, enableSuperMixins: enableSuperMixins, generateDart2jsHints: generateDart2jsHints, generateHints: generateHints, generateLints: generateLints);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AnalysisOptions", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (enableAsync != null) {
@@ skipping 37 matching lines @@
           generateDart2jsHints == other.generateDart2jsHints &&
           generateHints == other.generateHints &&
           generateLints == other.generateLints;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, enableAsync.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, enableDeferredLoading.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, enableEnums.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, enableNullAwareOperators.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, enableSuperMixins.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, generateDart2jsHints.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, generateHints.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, generateLints.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, enableAsync.hashCode);
+    hash = JenkinsSmiHash.combine(hash, enableDeferredLoading.hashCode);
+    hash = JenkinsSmiHash.combine(hash, enableEnums.hashCode);
+    hash = JenkinsSmiHash.combine(hash, enableNullAwareOperators.hashCode);
+    hash = JenkinsSmiHash.combine(hash, enableSuperMixins.hashCode);
+    hash = JenkinsSmiHash.combine(hash, generateDart2jsHints.hashCode);
+    hash = JenkinsSmiHash.combine(hash, generateHints.hashCode);
+    hash = JenkinsSmiHash.combine(hash, generateLints.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisService
  *
  * enum {
  *   FOLDING
  *   HIGHLIGHTS
  *   IMPLEMENTED
  *   INVALIDATE
  *   NAVIGATION
  *   OCCURRENCES
  *   OUTLINE
  *   OVERRIDES
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisService implements Enum {
   static const FOLDING = const AnalysisService._("FOLDING");
 
   static const HIGHLIGHTS = const AnalysisService._("HIGHLIGHTS");
 
   static const IMPLEMENTED = const AnalysisService._("IMPLEMENTED");
 
   /**
    * This service is not currently implemented and will become a
@@ skipping 57 matching lines @@
   String toJson() => name;
 }
 
 /**
  * AnalysisStatus
  *
  * {
  *   "isAnalyzing": bool
  *   "analysisTarget": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class AnalysisStatus implements HasToJson {
   bool _isAnalyzing;
 
   String _analysisTarget;
 
   /**
    * True if analysis is currently being performed.
    */
   bool get isAnalyzing => _isAnalyzing;
@@ skipping 25 matching lines @@
     this.analysisTarget = analysisTarget;
   }
 
   factory AnalysisStatus.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool isAnalyzing;
       if (json.containsKey("isAnalyzing")) {
-        isAnalyzing = jsonDecoder._decodeBool(jsonPath + ".isAnalyzing", json["isAnalyzing"]);
+        isAnalyzing = jsonDecoder.decodeBool(jsonPath + ".isAnalyzing", json["isAnalyzing"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isAnalyzing");
       }
       String analysisTarget;
       if (json.containsKey("analysisTarget")) {
-        analysisTarget = jsonDecoder._decodeString(jsonPath + ".analysisTarget", json["analysisTarget"]);
+        analysisTarget = jsonDecoder.decodeString(jsonPath + ".analysisTarget", json["analysisTarget"]);
       }
       return new AnalysisStatus(isAnalyzing, analysisTarget: analysisTarget);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AnalysisStatus", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["isAnalyzing"] = isAnalyzing;
@@ skipping 11 matching lines @@
     if (other is AnalysisStatus) {
       return isAnalyzing == other.isAnalyzing &&
           analysisTarget == other.analysisTarget;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, isAnalyzing.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, analysisTarget.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, isAnalyzing.hashCode);
+    hash = JenkinsSmiHash.combine(hash, analysisTarget.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ChangeContentOverlay
  *
  * {
  *   "type": "change"
  *   "edits": List<SourceEdit>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ChangeContentOverlay implements HasToJson {
   List<SourceEdit> _edits;
 
   /**
    * The edits to be applied to the file.
    */
   List<SourceEdit> get edits => _edits;
 
   /**
@@ skipping 11 matching lines @@
   factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "change") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "change", json);
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       return new ChangeContentOverlay(edits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "change";
     result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ChangeContentOverlay) {
-      return _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
+      return listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, 873118866);
-    hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, 873118866);
+    hash = JenkinsSmiHash.combine(hash, edits.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * CompletionSuggestion
  *
  * {
  *   "kind": CompletionSuggestionKind
  *   "relevance": int
  *   "completion": String
  *   "selectionOffset": int
  *   "selectionLength": int
  *   "isDeprecated": bool
  *   "isPotential": bool
  *   "docSummary": optional String
  *   "docComplete": optional String
  *   "declaringType": optional String
  *   "element": optional Element
  *   "returnType": optional String
  *   "parameterNames": optional List<String>
  *   "parameterTypes": optional List<String>
  *   "requiredParameterCount": optional int
  *   "hasNamedParameters": optional bool
  *   "parameterName": optional String
  *   "parameterType": optional String
  *   "importUri": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class CompletionSuggestion implements HasToJson {
   CompletionSuggestionKind _kind;
 
   int _relevance;
 
   String _completion;
 
   int _selectionOffset;
 
@@ skipping 332 matching lines @@
     }
     if (json is Map) {
       CompletionSuggestionKind kind;
       if (json.containsKey("kind")) {
         kind = new CompletionSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       int relevance;
       if (json.containsKey("relevance")) {
-        relevance = jsonDecoder._decodeInt(jsonPath + ".relevance", json["relevance"]);
+        relevance = jsonDecoder.decodeInt(jsonPath + ".relevance", json["relevance"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "relevance");
       }
       String completion;
       if (json.containsKey("completion")) {
-        completion = jsonDecoder._decodeString(jsonPath + ".completion", json["completion"]);
+        completion = jsonDecoder.decodeString(jsonPath + ".completion", json["completion"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "completion");
       }
       int selectionOffset;
       if (json.containsKey("selectionOffset")) {
-        selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
+        selectionOffset = jsonDecoder.decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionOffset");
       }
       int selectionLength;
       if (json.containsKey("selectionLength")) {
-        selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
+        selectionLength = jsonDecoder.decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionLength");
       }
       bool isDeprecated;
       if (json.containsKey("isDeprecated")) {
-        isDeprecated = jsonDecoder._decodeBool(jsonPath + ".isDeprecated", json["isDeprecated"]);
+        isDeprecated = jsonDecoder.decodeBool(jsonPath + ".isDeprecated", json["isDeprecated"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isDeprecated");
       }
       bool isPotential;
       if (json.containsKey("isPotential")) {
-        isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["isPotential"]);
+        isPotential = jsonDecoder.decodeBool(jsonPath + ".isPotential", json["isPotential"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isPotential");
       }
       String docSummary;
       if (json.containsKey("docSummary")) {
-        docSummary = jsonDecoder._decodeString(jsonPath + ".docSummary", json["docSummary"]);
+        docSummary = jsonDecoder.decodeString(jsonPath + ".docSummary", json["docSummary"]);
       }
       String docComplete;
       if (json.containsKey("docComplete")) {
-        docComplete = jsonDecoder._decodeString(jsonPath + ".docComplete", json["docComplete"]);
+        docComplete = jsonDecoder.decodeString(jsonPath + ".docComplete", json["docComplete"]);
       }
       String declaringType;
       if (json.containsKey("declaringType")) {
-        declaringType = jsonDecoder._decodeString(jsonPath + ".declaringType", json["declaringType"]);
+        declaringType = jsonDecoder.decodeString(jsonPath + ".declaringType", json["declaringType"]);
       }
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       }
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
       }
       List<String> parameterNames;
       if (json.containsKey("parameterNames")) {
-        parameterNames = jsonDecoder._decodeList(jsonPath + ".parameterNames", json["parameterNames"], jsonDecoder._decodeString);
+        parameterNames = jsonDecoder.decodeList(jsonPath + ".parameterNames", json["parameterNames"], jsonDecoder.decodeString);
       }
       List<String> parameterTypes;
       if (json.containsKey("parameterTypes")) {
-        parameterTypes = jsonDecoder._decodeList(jsonPath + ".parameterTypes", json["parameterTypes"], jsonDecoder._decodeString);
+        parameterTypes = jsonDecoder.decodeList(jsonPath + ".parameterTypes", json["parameterTypes"], jsonDecoder.decodeString);
       }
       int requiredParameterCount;
       if (json.containsKey("requiredParameterCount")) {
-        requiredParameterCount = jsonDecoder._decodeInt(jsonPath + ".requiredParameterCount", json["requiredParameterCount"]);
+        requiredParameterCount = jsonDecoder.decodeInt(jsonPath + ".requiredParameterCount", json["requiredParameterCount"]);
       }
       bool hasNamedParameters;
       if (json.containsKey("hasNamedParameters")) {
-        hasNamedParameters = jsonDecoder._decodeBool(jsonPath + ".hasNamedParameters", json["hasNamedParameters"]);
+        hasNamedParameters = jsonDecoder.decodeBool(jsonPath + ".hasNamedParameters", json["hasNamedParameters"]);
       }
       String parameterName;
       if (json.containsKey("parameterName")) {
-        parameterName = jsonDecoder._decodeString(jsonPath + ".parameterName", json["parameterName"]);
+        parameterName = jsonDecoder.decodeString(jsonPath + ".parameterName", json["parameterName"]);
       }
       String parameterType;
       if (json.containsKey("parameterType")) {
-        parameterType = jsonDecoder._decodeString(jsonPath + ".parameterType", json["parameterType"]);
+        parameterType = jsonDecoder.decodeString(jsonPath + ".parameterType", json["parameterType"]);
       }
       String importUri;
       if (json.containsKey("importUri")) {
-        importUri = jsonDecoder._decodeString(jsonPath + ".importUri", json["importUri"]);
+        importUri = jsonDecoder.decodeString(jsonPath + ".importUri", json["importUri"]);
       }
       return new CompletionSuggestion(kind, relevance, completion, selectionOffset, selectionLength, isDeprecated, isPotential, docSummary: docSummary, docComplete: docComplete, declaringType: declaringType, element: element, returnType: returnType, parameterNames: parameterNames, parameterTypes: parameterTypes, requiredParameterCount: requiredParameterCount, hasNamedParameters: hasNamedParameters, parameterName: parameterName, parameterType: parameterType, importUri: importUri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
@@ skipping 53 matching lines @@
           completion == other.completion &&
           selectionOffset == other.selectionOffset &&
           selectionLength == other.selectionLength &&
           isDeprecated == other.isDeprecated &&
           isPotential == other.isPotential &&
           docSummary == other.docSummary &&
           docComplete == other.docComplete &&
           declaringType == other.declaringType &&
           element == other.element &&
           returnType == other.returnType &&
-          _listEqual(parameterNames, other.parameterNames, (String a, String b) => a == b) &&
-          _listEqual(parameterTypes, other.parameterTypes, (String a, String b) => a == b) &&
+          listEqual(parameterNames, other.parameterNames, (String a, String b) => a == b) &&
+          listEqual(parameterTypes, other.parameterTypes, (String a, String b) => a == b) &&
           requiredParameterCount == other.requiredParameterCount &&
           hasNamedParameters == other.hasNamedParameters &&
           parameterName == other.parameterName &&
           parameterType == other.parameterType &&
           importUri == other.importUri;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, relevance.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, completion.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, isDeprecated.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, isPotential.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, docSummary.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, docComplete.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, declaringType.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, element.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameterNames.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameterTypes.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, requiredParameterCount.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, hasNamedParameters.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameterName.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameterType.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, importUri.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, relevance.hashCode);
+    hash = JenkinsSmiHash.combine(hash, completion.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selectionLength.hashCode);
+    hash = JenkinsSmiHash.combine(hash, isDeprecated.hashCode);
+    hash = JenkinsSmiHash.combine(hash, isPotential.hashCode);
+    hash = JenkinsSmiHash.combine(hash, docSummary.hashCode);
+    hash = JenkinsSmiHash.combine(hash, docComplete.hashCode);
+    hash = JenkinsSmiHash.combine(hash, declaringType.hashCode);
+    hash = JenkinsSmiHash.combine(hash, element.hashCode);
+    hash = JenkinsSmiHash.combine(hash, returnType.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameterNames.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameterTypes.hashCode);
+    hash = JenkinsSmiHash.combine(hash, requiredParameterCount.hashCode);
+    hash = JenkinsSmiHash.combine(hash, hasNamedParameters.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameterName.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameterType.hashCode);
+    hash = JenkinsSmiHash.combine(hash, importUri.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * CompletionSuggestionKind
  *
  * enum {
  *   ARGUMENT_LIST
  *   IMPORT
  *   IDENTIFIER
  *   INVOCATION
  *   KEYWORD
  *   NAMED_ARGUMENT
  *   OPTIONAL_ARGUMENT
  *   PARAMETER
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class CompletionSuggestionKind implements Enum {
   /**
    * A list of arguments for the method or function that is being invoked. For
    * this suggestion kind, the completion field is a textual representation of
    * the invocation and the parameterNames, parameterTypes, and
    * requiredParameterCount attributes are defined.
    */
   static const ARGUMENT_LIST = const CompletionSuggestionKind._("ARGUMENT_LIST");
 
@@ skipping 85 matching lines @@
  *
  * {
  *   "kind": ElementKind
  *   "name": String
  *   "location": optional Location
  *   "flags": int
  *   "parameters": optional String
  *   "returnType": optional String
  *   "typeParameters": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class Element implements HasToJson {
   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}) {
@@ skipping 154 matching lines @@
     }
     if (json is Map) {
       ElementKind kind;
       if (json.containsKey("kind")) {
         kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       String name;
       if (json.containsKey("name")) {
-        name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
+        name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       Location location;
       if (json.containsKey("location")) {
         location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
       }
       int flags;
       if (json.containsKey("flags")) {
-        flags = jsonDecoder._decodeInt(jsonPath + ".flags", json["flags"]);
+        flags = jsonDecoder.decodeInt(jsonPath + ".flags", json["flags"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "flags");
       }
       String parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["parameters"]);
+        parameters = jsonDecoder.decodeString(jsonPath + ".parameters", json["parameters"]);
       }
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
       }
       String typeParameters;
       if (json.containsKey("typeParameters")) {
-        typeParameters = jsonDecoder._decodeString(jsonPath + ".typeParameters", json["typeParameters"]);
+        typeParameters = jsonDecoder.decodeString(jsonPath + ".typeParameters", json["typeParameters"]);
       }
       return new Element(kind, name, flags, location: location, parameters: parameters, returnType: returnType, typeParameters: typeParameters);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Element", json);
     }
   }
 
   bool get isAbstract => (flags & FLAG_ABSTRACT) != 0;
   bool get isConst => (flags & FLAG_CONST) != 0;
   bool get isFinal => (flags & FLAG_FINAL) != 0;
@@ skipping 34 matching lines @@
           parameters == other.parameters &&
           returnType == other.returnType &&
           typeParameters == other.typeParameters;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, name.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, location.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, flags.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, typeParameters.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, name.hashCode);
+    hash = JenkinsSmiHash.combine(hash, location.hashCode);
+    hash = JenkinsSmiHash.combine(hash, flags.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameters.hashCode);
+    hash = JenkinsSmiHash.combine(hash, returnType.hashCode);
+    hash = JenkinsSmiHash.combine(hash, typeParameters.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ElementKind
  *
  * enum {
  *   CLASS
  *   CLASS_TYPE_ALIAS
  *   COMPILATION_UNIT
@@ skipping 10 matching lines @@
  *   METHOD
  *   PARAMETER
  *   PREFIX
  *   SETTER
  *   TOP_LEVEL_VARIABLE
  *   TYPE_PARAMETER
  *   UNIT_TEST_GROUP
  *   UNIT_TEST_TEST
  *   UNKNOWN
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ElementKind implements Enum {
   static const CLASS = const ElementKind._("CLASS");
 
   static const CLASS_TYPE_ALIAS = const ElementKind._("CLASS_TYPE_ALIAS");
 
   static const COMPILATION_UNIT = const ElementKind._("COMPILATION_UNIT");
 
   static const CONSTRUCTOR = const ElementKind._("CONSTRUCTOR");
 
@@ skipping 109 matching lines @@
   String toJson() => name;
 }
 
 /**
  * ExecutableFile
  *
  * {
  *   "file": FilePath
  *   "kind": ExecutableKind
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutableFile implements HasToJson {
   String _file;
 
   ExecutableKind _kind;
 
   /**
    * The path of the executable file.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.kind = kind;
   }
 
   factory ExecutableFile.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       ExecutableKind kind;
       if (json.containsKey("kind")) {
         kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       return new ExecutableFile(file, kind);
@@ skipping 17 matching lines @@
     if (other is ExecutableFile) {
       return file == other.file &&
           kind == other.kind;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ExecutableKind
  *
  * enum {
  *   CLIENT
  *   EITHER
  *   NOT_EXECUTABLE
  *   SERVER
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutableKind implements Enum {
   static const CLIENT = const ExecutableKind._("CLIENT");
 
   static const EITHER = const ExecutableKind._("EITHER");
 
   static const NOT_EXECUTABLE = const ExecutableKind._("NOT_EXECUTABLE");
 
   static const SERVER = const ExecutableKind._("SERVER");
 
@@ skipping 36 matching lines @@
 
   String toJson() => name;
 }
 
 /**
  * ExecutionService
  *
  * enum {
  *   LAUNCH_DATA
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExecutionService implements Enum {
   static const LAUNCH_DATA = const ExecutionService._("LAUNCH_DATA");
 
   /**
    * A list containing all of the enum values that are defined.
    */
   static const List<ExecutionService> VALUES = const <ExecutionService>[LAUNCH_DATA];
 
   final String name;
@@ skipping 25 matching lines @@
   String toJson() => name;
 }
 
 /**
  * FileKind
  *
  * enum {
  *   LIBRARY
  *   PART
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class FileKind implements Enum {
   static const LIBRARY = const FileKind._("LIBRARY");
 
   static const PART = const FileKind._("PART");
 
   /**
    * A list containing all of the enum values that are defined.
    */
   static const List<FileKind> VALUES = const <FileKind>[LIBRARY, PART];
@@ skipping 32 matching lines @@
 /**
  * FoldingKind
  *
  * enum {
  *   COMMENT
  *   CLASS_MEMBER
  *   DIRECTIVES
  *   DOCUMENTATION_COMMENT
  *   TOP_LEVEL_DECLARATION
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class FoldingKind implements Enum {
   static const COMMENT = const FoldingKind._("COMMENT");
 
   static const CLASS_MEMBER = const FoldingKind._("CLASS_MEMBER");
 
   static const DIRECTIVES = const FoldingKind._("DIRECTIVES");
 
   static const DOCUMENTATION_COMMENT = const FoldingKind._("DOCUMENTATION_COMMENT");
 
@@ skipping 42 matching lines @@
 }
 
 /**
  * FoldingRegion
  *
  * {
  *   "kind": FoldingKind
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class FoldingRegion implements HasToJson {
   FoldingKind _kind;
 
   int _offset;
 
   int _length;
 
   /**
    * The kind of the region.
@@ skipping 46 matching lines @@
     }
     if (json is Map) {
       FoldingKind kind;
       if (json.containsKey("kind")) {
         kind = new FoldingKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new FoldingRegion(kind, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "FoldingRegion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 13 matching lines @@
       return kind == other.kind &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * GeneralAnalysisService
  *
  * enum {
  *   ANALYZED_FILES
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class GeneralAnalysisService implements Enum {
   static const ANALYZED_FILES = const GeneralAnalysisService._("ANALYZED_FILES");
 
   /**
    * A list containing all of the enum values that are defined.
    */
   static const List<GeneralAnalysisService> VALUES = const <GeneralAnalysisService>[ANALYZED_FILES];
 
   final String name;
@@ skipping 26 matching lines @@
 }
 
 /**
  * HighlightRegion
  *
  * {
  *   "type": HighlightRegionType
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class HighlightRegion implements HasToJson {
   HighlightRegionType _type;
 
   int _offset;
 
   int _length;
 
   /**
    * The type of highlight associated with the region.
@@ skipping 46 matching lines @@
     }
     if (json is Map) {
       HighlightRegionType type;
       if (json.containsKey("type")) {
         type = new HighlightRegionType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "type");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new HighlightRegion(type, offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "HighlightRegion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 13 matching lines @@
       return type == other.type &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, type.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, type.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * HighlightRegionType
  *
  * enum {
  *   ANNOTATION
  *   BUILT_IN
  *   CLASS
@@ skipping 61 matching lines @@
  *   TOP_LEVEL_GETTER_DECLARATION
  *   TOP_LEVEL_GETTER_REFERENCE
  *   TOP_LEVEL_SETTER_DECLARATION
  *   TOP_LEVEL_SETTER_REFERENCE
  *   TOP_LEVEL_VARIABLE_DECLARATION
  *   TYPE_NAME_DYNAMIC
  *   TYPE_PARAMETER
  *   UNRESOLVED_INSTANCE_MEMBER_REFERENCE
  *   VALID_STRING_ESCAPE
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class HighlightRegionType implements Enum {
   static const ANNOTATION = const HighlightRegionType._("ANNOTATION");
 
   static const BUILT_IN = const HighlightRegionType._("BUILT_IN");
 
   static const CLASS = const HighlightRegionType._("CLASS");
 
   static const COMMENT_BLOCK = const HighlightRegionType._("COMMENT_BLOCK");
 
@@ skipping 469 matching lines @@
  *   "containingLibraryPath": optional String
  *   "containingLibraryName": optional String
  *   "containingClassDescription": optional String
  *   "dartdoc": optional String
  *   "elementDescription": optional String
  *   "elementKind": optional String
  *   "parameter": optional String
  *   "propagatedType": optional String
  *   "staticType": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class HoverInformation implements HasToJson {
   int _offset;
 
   int _length;
 
   String _containingLibraryPath;
 
   String _containingLibraryName;
 
@@ skipping 197 matching lines @@
     this.staticType = staticType;
   }
 
   factory HoverInformation.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       String containingLibraryPath;
       if (json.containsKey("containingLibraryPath")) {
-        containingLibraryPath = jsonDecoder._decodeString(jsonPath + ".containingLibraryPath", json["containingLibraryPath"]);
+        containingLibraryPath = jsonDecoder.decodeString(jsonPath + ".containingLibraryPath", json["containingLibraryPath"]);
       }
       String containingLibraryName;
       if (json.containsKey("containingLibraryName")) {
-        containingLibraryName = jsonDecoder._decodeString(jsonPath + ".containingLibraryName", json["containingLibraryName"]);
+        containingLibraryName = jsonDecoder.decodeString(jsonPath + ".containingLibraryName", json["containingLibraryName"]);
       }
       String containingClassDescription;
       if (json.containsKey("containingClassDescription")) {
-        containingClassDescription = jsonDecoder._decodeString(jsonPath + ".containingClassDescription", json["containingClassDescription"]);
+        containingClassDescription = jsonDecoder.decodeString(jsonPath + ".containingClassDescription", json["containingClassDescription"]);
       }
       String dartdoc;
       if (json.containsKey("dartdoc")) {
-        dartdoc = jsonDecoder._decodeString(jsonPath + ".dartdoc", json["dartdoc"]);
+        dartdoc = jsonDecoder.decodeString(jsonPath + ".dartdoc", json["dartdoc"]);
       }
       String elementDescription;
       if (json.containsKey("elementDescription")) {
-        elementDescription = jsonDecoder._decodeString(jsonPath + ".elementDescription", json["elementDescription"]);
+        elementDescription = jsonDecoder.decodeString(jsonPath + ".elementDescription", json["elementDescription"]);
       }
       String elementKind;
       if (json.containsKey("elementKind")) {
-        elementKind = jsonDecoder._decodeString(jsonPath + ".elementKind", json["elementKind"]);
+        elementKind = jsonDecoder.decodeString(jsonPath + ".elementKind", json["elementKind"]);
       }
       String parameter;
       if (json.containsKey("parameter")) {
-        parameter = jsonDecoder._decodeString(jsonPath + ".parameter", json["parameter"]);
+        parameter = jsonDecoder.decodeString(jsonPath + ".parameter", json["parameter"]);
       }
       String propagatedType;
       if (json.containsKey("propagatedType")) {
-        propagatedType = jsonDecoder._decodeString(jsonPath + ".propagatedType", json["propagatedType"]);
+        propagatedType = jsonDecoder.decodeString(jsonPath + ".propagatedType", json["propagatedType"]);
       }
       String staticType;
       if (json.containsKey("staticType")) {
-        staticType = jsonDecoder._decodeString(jsonPath + ".staticType", json["staticType"]);
+        staticType = jsonDecoder.decodeString(jsonPath + ".staticType", json["staticType"]);
       }
       return new HoverInformation(offset, length, containingLibraryPath: containingLibraryPath, containingLibraryName: containingLibraryName, containingClassDescription: containingClassDescription, dartdoc: dartdoc, elementDescription: elementDescription, elementKind: elementKind, parameter: parameter, propagatedType: propagatedType, staticType: staticType);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "HoverInformation", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
@@ skipping 45 matching lines @@
           parameter == other.parameter &&
           propagatedType == other.propagatedType &&
           staticType == other.staticType;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, containingLibraryPath.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, containingLibraryName.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, containingClassDescription.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, dartdoc.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, elementDescription.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, elementKind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameter.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, propagatedType.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, staticType.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, containingLibraryPath.hashCode);
+    hash = JenkinsSmiHash.combine(hash, containingLibraryName.hashCode);
+    hash = JenkinsSmiHash.combine(hash, containingClassDescription.hashCode);
+    hash = JenkinsSmiHash.combine(hash, dartdoc.hashCode);
+    hash = JenkinsSmiHash.combine(hash, elementDescription.hashCode);
+    hash = JenkinsSmiHash.combine(hash, elementKind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameter.hashCode);
+    hash = JenkinsSmiHash.combine(hash, propagatedType.hashCode);
+    hash = JenkinsSmiHash.combine(hash, staticType.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ImplementedClass
  *
  * {
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ImplementedClass implements HasToJson {
   int _offset;
 
   int _length;
 
   /**
    * The offset of the name of the implemented class.
    */
   int get offset => _offset;
@@ skipping 24 matching lines @@
     this.length = length;
   }
 
   factory ImplementedClass.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new ImplementedClass(offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ImplementedClass", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 11 matching lines @@
     if (other is ImplementedClass) {
       return offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ImplementedMember
  *
  * {
  *   "offset": int
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ImplementedMember implements HasToJson {
   int _offset;
 
   int _length;
 
   /**
    * The offset of the name of the implemented member.
    */
   int get offset => _offset;
@@ skipping 24 matching lines @@
     this.length = length;
   }
 
   factory ImplementedMember.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new ImplementedMember(offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ImplementedMember", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 11 matching lines @@
     if (other is ImplementedMember) {
       return offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * LinkedEditGroup
  *
  * {
  *   "positions": List<Position>
  *   "length": int
  *   "suggestions": List<LinkedEditSuggestion>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class LinkedEditGroup implements HasToJson {
   List<Position> _positions;
 
   int _length;
 
   List<LinkedEditSuggestion> _suggestions;
 
   /**
    * The positions of the regions that should be edited simultaneously.
@@ skipping 42 matching lines @@
     this.suggestions = suggestions;
   }
 
   factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<Position> positions;
       if (json.containsKey("positions")) {
-        positions = jsonDecoder._decodeList(jsonPath + ".positions", json["positions"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, jsonPath, json));
+        positions = jsonDecoder.decodeList(jsonPath + ".positions", json["positions"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "positions");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<LinkedEditSuggestion> suggestions;
       if (json.containsKey("suggestions")) {
-        suggestions = jsonDecoder._decodeList(jsonPath + ".suggestions", json["suggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson(jsonDecoder, jsonPath, json));
+        suggestions = jsonDecoder.decodeList(jsonPath + ".suggestions", json["suggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "suggestions");
       }
       return new LinkedEditGroup(positions, length, suggestions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup", json);
     }
   }
 
   /**
@@ skipping 23 matching lines @@
   void addSuggestion(LinkedEditSuggestion suggestion) {
     suggestions.add(suggestion);
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is LinkedEditGroup) {
-      return _listEqual(positions, other.positions, (Position a, Position b) => a == b) &&
+      return listEqual(positions, other.positions, (Position a, Position b) => a == b) &&
           length == other.length &&
-          _listEqual(suggestions, other.suggestions, (LinkedEditSuggestion a, LinkedEditSuggestion b) => a == b);
+          listEqual(suggestions, other.suggestions, (LinkedEditSuggestion a, LinkedEditSuggestion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, positions.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, suggestions.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, positions.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, suggestions.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * LinkedEditSuggestion
  *
  * {
  *   "value": String
  *   "kind": LinkedEditSuggestionKind
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class LinkedEditSuggestion implements HasToJson {
   String _value;
 
   LinkedEditSuggestionKind _kind;
 
   /**
    * The value that could be used to replace all of the linked edit regions.
    */
   String get value => _value;
@@ skipping 24 matching lines @@
     this.kind = kind;
   }
 
   factory LinkedEditSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String value;
       if (json.containsKey("value")) {
-        value = jsonDecoder._decodeString(jsonPath + ".value", json["value"]);
+        value = jsonDecoder.decodeString(jsonPath + ".value", json["value"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "value");
       }
       LinkedEditSuggestionKind kind;
       if (json.containsKey("kind")) {
         kind = new LinkedEditSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       return new LinkedEditSuggestion(value, kind);
@@ skipping 17 matching lines @@
     if (other is LinkedEditSuggestion) {
       return value == other.value &&
           kind == other.kind;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, value.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, value.hashCode);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * LinkedEditSuggestionKind
  *
  * enum {
  *   METHOD
  *   PARAMETER
  *   TYPE
  *   VARIABLE
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class LinkedEditSuggestionKind implements Enum {
   static const METHOD = const LinkedEditSuggestionKind._("METHOD");
 
   static const PARAMETER = const LinkedEditSuggestionKind._("PARAMETER");
 
   static const TYPE = const LinkedEditSuggestionKind._("TYPE");
 
   static const VARIABLE = const LinkedEditSuggestionKind._("VARIABLE");
 
@@ skipping 40 matching lines @@
 /**
  * Location
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "startLine": int
  *   "startColumn": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class Location implements HasToJson {
   String _file;
 
   int _offset;
 
   int _length;
 
   int _startLine;
 
@@ skipping 76 matching lines @@
     this.startColumn = startColumn;
   }
 
   factory Location.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       int startLine;
       if (json.containsKey("startLine")) {
-        startLine = jsonDecoder._decodeInt(jsonPath + ".startLine", json["startLine"]);
+        startLine = jsonDecoder.decodeInt(jsonPath + ".startLine", json["startLine"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "startLine");
       }
       int startColumn;
       if (json.containsKey("startColumn")) {
-        startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["startColumn"]);
+        startColumn = jsonDecoder.decodeInt(jsonPath + ".startColumn", json["startColumn"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "startColumn");
       }
       return new Location(file, offset, length, startLine, startColumn);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Location", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 17 matching lines @@
           length == other.length &&
           startLine == other.startLine &&
           startColumn == other.startColumn;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, startLine.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, startColumn.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, startLine.hashCode);
+    hash = JenkinsSmiHash.combine(hash, startColumn.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * NavigationRegion
  *
  * {
  *   "offset": int
  *   "length": int
  *   "targets": List<int>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class NavigationRegion implements HasToJson {
   int _offset;
 
   int _length;
 
   List<int> _targets;
 
   /**
    * The offset of the region from which the user can navigate.
@@ skipping 44 matching lines @@
     this.targets = targets;
   }
 
   factory NavigationRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<int> targets;
       if (json.containsKey("targets")) {
-        targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], jsonDecoder._decodeInt);
+        targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "targets");
       }
       return new NavigationRegion(offset, length, targets);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "NavigationRegion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["targets"] = targets;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is NavigationRegion) {
       return offset == other.offset &&
           length == other.length &&
-          _listEqual(targets, other.targets, (int a, int b) => a == b);
+          listEqual(targets, other.targets, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, targets.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, targets.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * NavigationTarget
  *
  * {
  *   "kind": ElementKind
  *   "fileIndex": int
  *   "offset": int
  *   "length": int
  *   "startLine": int
  *   "startColumn": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class NavigationTarget implements HasToJson {
   ElementKind _kind;
 
   int _fileIndex;
 
   int _offset;
 
   int _length;
 
@@ skipping 100 matching lines @@
     }
     if (json is Map) {
       ElementKind kind;
       if (json.containsKey("kind")) {
         kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       int fileIndex;
       if (json.containsKey("fileIndex")) {
-        fileIndex = jsonDecoder._decodeInt(jsonPath + ".fileIndex", json["fileIndex"]);
+        fileIndex = jsonDecoder.decodeInt(jsonPath + ".fileIndex", json["fileIndex"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fileIndex");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       int startLine;
       if (json.containsKey("startLine")) {
-        startLine = jsonDecoder._decodeInt(jsonPath + ".startLine", json["startLine"]);
+        startLine = jsonDecoder.decodeInt(jsonPath + ".startLine", json["startLine"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "startLine");
       }
       int startColumn;
       if (json.containsKey("startColumn")) {
-        startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["startColumn"]);
+        startColumn = jsonDecoder.decodeInt(jsonPath + ".startColumn", json["startColumn"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "startColumn");
       }
       return new NavigationTarget(kind, fileIndex, offset, length, startLine, startColumn);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "NavigationTarget", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 19 matching lines @@
           length == other.length &&
           startLine == other.startLine &&
           startColumn == other.startColumn;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, fileIndex.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, startLine.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, startColumn.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, fileIndex.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, startLine.hashCode);
+    hash = JenkinsSmiHash.combine(hash, startColumn.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * Occurrences
  *
  * {
  *   "element": Element
  *   "offsets": List<int>
  *   "length": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class Occurrences implements HasToJson {
   Element _element;
 
   List<int> _offsets;
 
   int _length;
 
   /**
    * The element that was referenced.
@@ skipping 46 matching lines @@
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "element");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
-        offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
+        offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offsets");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new Occurrences(element, offsets, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Occurrences", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offsets"] = offsets;
     result["length"] = length;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is Occurrences) {
       return element == other.element &&
-          _listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
+          listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, element.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offsets.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, element.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offsets.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * Outline
  *
  * {
  *   "element": Element
  *   "offset": int
  *   "length": int
  *   "children": optional List<Outline>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class Outline implements HasToJson {
   Element _element;
 
   int _offset;
 
   int _length;
 
   List<Outline> _children;
 
@@ skipping 69 matching lines @@
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "element");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<Outline> children;
       if (json.containsKey("children")) {
-        children = jsonDecoder._decodeList(jsonPath + ".children", json["children"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath, json));
+        children = jsonDecoder.decodeList(jsonPath + ".children", json["children"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath, json));
       }
       return new Outline(element, offset, length, children: children);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Outline", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offset"] = offset;
     result["length"] = length;
     if (children != null) {
       result["children"] = children.map((Outline value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is Outline) {
       return element == other.element &&
           offset == other.offset &&
           length == other.length &&
-          _listEqual(children, other.children, (Outline a, Outline b) => a == b);
+          listEqual(children, other.children, (Outline a, Outline b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, element.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, children.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, element.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, children.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * Override
  *
  * {
  *   "offset": int
  *   "length": int
  *   "superclassMember": optional OverriddenMember
  *   "interfaceMembers": optional List<OverriddenMember>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class Override implements HasToJson {
   int _offset;
 
   int _length;
 
   OverriddenMember _superclassMember;
 
   List<OverriddenMember> _interfaceMembers;
 
@@ skipping 62 matching lines @@
     this.interfaceMembers = interfaceMembers;
   }
 
   factory Override.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       OverriddenMember superclassMember;
       if (json.containsKey("superclassMember")) {
         superclassMember = new OverriddenMember.fromJson(jsonDecoder, jsonPath + ".superclassMember", json["superclassMember"]);
       }
       List<OverriddenMember> interfaceMembers;
       if (json.containsKey("interfaceMembers")) {
-        interfaceMembers = jsonDecoder._decodeList(jsonPath + ".interfaceMembers", json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMember.fromJson(jsonDecoder, jsonPath, json));
+        interfaceMembers = jsonDecoder.decodeList(jsonPath + ".interfaceMembers", json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMember.fromJson(jsonDecoder, jsonPath, json));
       }
       return new Override(offset, length, superclassMember: superclassMember, interfaceMembers: interfaceMembers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Override", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     if (superclassMember != null) {
       result["superclassMember"] = superclassMember.toJson();
     }
     if (interfaceMembers != null) {
       result["interfaceMembers"] = interfaceMembers.map((OverriddenMember value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is Override) {
       return offset == other.offset &&
           length == other.length &&
           superclassMember == other.superclassMember &&
-          _listEqual(interfaceMembers, other.interfaceMembers, (OverriddenMember a, OverriddenMember b) => a == b);
+          listEqual(interfaceMembers, other.interfaceMembers, (OverriddenMember a, OverriddenMember b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, superclassMember.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, interfaceMembers.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, superclassMember.hashCode);
+    hash = JenkinsSmiHash.combine(hash, interfaceMembers.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * OverriddenMember
  *
  * {
  *   "element": Element
  *   "className": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class OverriddenMember implements HasToJson {
   Element _element;
 
   String _className;
 
   /**
    * The element that is being overridden.
    */
   Element get element => _element;
@@ skipping 30 matching lines @@
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "element");
       }
       String className;
       if (json.containsKey("className")) {
-        className = jsonDecoder._decodeString(jsonPath + ".className", json["className"]);
+        className = jsonDecoder.decodeString(jsonPath + ".className", json["className"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "className");
       }
       return new OverriddenMember(element, className);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "OverriddenMember", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 11 matching lines @@
     if (other is OverriddenMember) {
       return element == other.element &&
           className == other.className;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, element.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, className.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, element.hashCode);
+    hash = JenkinsSmiHash.combine(hash, className.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * Position
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class Position implements HasToJson {
   String _file;
 
   int _offset;
 
   /**
    * The file containing the position.
    */
   String get file => _file;
@@ skipping 24 matching lines @@
     this.offset = offset;
   }
 
   factory Position.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new Position(file, offset);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Position", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 11 matching lines @@
     if (other is Position) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * PubStatus
  *
  * {
  *   "isListingPackageDirs": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class PubStatus implements HasToJson {
   bool _isListingPackageDirs;
 
   /**
    * True if the server is currently running pub to produce a list of package
    * directories.
    */
   bool get isListingPackageDirs => _isListingPackageDirs;
 
@@ skipping 10 matching lines @@
     this.isListingPackageDirs = isListingPackageDirs;
   }
 
   factory PubStatus.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool isListingPackageDirs;
       if (json.containsKey("isListingPackageDirs")) {
-        isListingPackageDirs = jsonDecoder._decodeBool(jsonPath + ".isListingPackageDirs", json["isListingPackageDirs"]);
+        isListingPackageDirs = jsonDecoder.decodeBool(jsonPath + ".isListingPackageDirs", json["isListingPackageDirs"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isListingPackageDirs");
       }
       return new PubStatus(isListingPackageDirs);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "PubStatus", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["isListingPackageDirs"] = isListingPackageDirs;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is PubStatus) {
       return isListingPackageDirs == other.isListingPackageDirs;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, isListingPackageDirs.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, isListingPackageDirs.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RefactoringKind
  *
  * enum {
  *   CONVERT_GETTER_TO_METHOD
  *   CONVERT_METHOD_TO_GETTER
  *   EXTRACT_LOCAL_VARIABLE
  *   EXTRACT_METHOD
  *   INLINE_LOCAL_VARIABLE
  *   INLINE_METHOD
  *   MOVE_FILE
  *   RENAME
  *   SORT_MEMBERS
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringKind implements Enum {
   static const CONVERT_GETTER_TO_METHOD = const RefactoringKind._("CONVERT_GETTER_TO_METHOD");
 
   static const CONVERT_METHOD_TO_GETTER = const RefactoringKind._("CONVERT_METHOD_TO_GETTER");
 
   static const EXTRACT_LOCAL_VARIABLE = const RefactoringKind._("EXTRACT_LOCAL_VARIABLE");
 
   static const EXTRACT_METHOD = const RefactoringKind._("EXTRACT_METHOD");
 
@@ skipping 60 matching lines @@
 /**
  * RefactoringMethodParameter
  *
  * {
  *   "id": optional String
  *   "kind": RefactoringMethodParameterKind
  *   "type": String
  *   "name": String
  *   "parameters": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringMethodParameter implements HasToJson {
   String _id;
 
   RefactoringMethodParameterKind _kind;
 
   String _type;
 
   String _name;
 
@@ skipping 78 matching lines @@
     this.parameters = parameters;
   }
 
   factory RefactoringMethodParameter.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"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       }
       RefactoringMethodParameterKind kind;
       if (json.containsKey("kind")) {
         kind = new RefactoringMethodParameterKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       String type;
       if (json.containsKey("type")) {
-        type = jsonDecoder._decodeString(jsonPath + ".type", json["type"]);
+        type = jsonDecoder.decodeString(jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "type");
       }
       String name;
       if (json.containsKey("name")) {
-        name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
+        name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       String parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["parameters"]);
+        parameters = jsonDecoder.decodeString(jsonPath + ".parameters", json["parameters"]);
       }
       return new RefactoringMethodParameter(kind, type, name, id: id, parameters: parameters);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameter", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (id != null) {
@@ skipping 19 matching lines @@
           type == other.type &&
           name == other.name &&
           parameters == other.parameters;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, type.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, name.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, type.hashCode);
+    hash = JenkinsSmiHash.combine(hash, name.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameters.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RefactoringFeedback
  *
  * {
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringFeedback implements HasToJson {
   RefactoringFeedback();
 
   factory RefactoringFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json, Map responseJson) {
-    return _refactoringFeedbackFromJson(jsonDecoder, jsonPath, json, responseJson);
+    return refactoringFeedbackFromJson(jsonDecoder, jsonPath, json, responseJson);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is RefactoringFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    return _JenkinsSmiHash.finish(hash);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RefactoringOptions
  *
  * {
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringOptions implements HasToJson {
   RefactoringOptions();
 
   factory RefactoringOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json, RefactoringKind kind) {
-    return _refactoringOptionsFromJson(jsonDecoder, jsonPath, json, kind);
+    return refactoringOptionsFromJson(jsonDecoder, jsonPath, json, kind);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is RefactoringOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    return _JenkinsSmiHash.finish(hash);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RefactoringMethodParameterKind
  *
  * enum {
  *   REQUIRED
  *   POSITIONAL
  *   NAMED
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringMethodParameterKind implements Enum {
   static const REQUIRED = const RefactoringMethodParameterKind._("REQUIRED");
 
   static const POSITIONAL = const RefactoringMethodParameterKind._("POSITIONAL");
 
   static const NAMED = const RefactoringMethodParameterKind._("NAMED");
 
   /**
    * A list containing all of the enum values that are defined.
@@ skipping 34 matching lines @@
 }
 
 /**
  * RefactoringProblem
  *
  * {
  *   "severity": RefactoringProblemSeverity
  *   "message": String
  *   "location": optional Location
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringProblem implements HasToJson {
   RefactoringProblemSeverity _severity;
 
   String _message;
 
   Location _location;
 
   /**
    * The severity of the problem being represented.
@@ skipping 49 matching lines @@
     }
     if (json is Map) {
       RefactoringProblemSeverity severity;
       if (json.containsKey("severity")) {
         severity = new RefactoringProblemSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "severity");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
+        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       Location location;
       if (json.containsKey("location")) {
         location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
       }
       return new RefactoringProblem(severity, message, location: location);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RefactoringProblem", json);
@@ skipping 19 matching lines @@
       return severity == other.severity &&
           message == other.message &&
           location == other.location;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, severity.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, message.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, location.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, severity.hashCode);
+    hash = JenkinsSmiHash.combine(hash, message.hashCode);
+    hash = JenkinsSmiHash.combine(hash, location.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RefactoringProblemSeverity
  *
  * enum {
  *   INFO
  *   WARNING
  *   ERROR
  *   FATAL
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RefactoringProblemSeverity implements Enum {
   static const INFO = const RefactoringProblemSeverity._("INFO");
 
   static const WARNING = const RefactoringProblemSeverity._("WARNING");
 
   static const ERROR = const RefactoringProblemSeverity._("ERROR");
 
   static const FATAL = const RefactoringProblemSeverity._("FATAL");
 
@@ skipping 28 matching lines @@
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "RefactoringProblemSeverity", json);
   }
 
   /**
    * Returns the [RefactoringProblemSeverity] with the maximal severity.
    */
   static RefactoringProblemSeverity max(RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>
-      _maxRefactoringProblemSeverity(a, b);
+      maxRefactoringProblemSeverity(a, b);
 
   @override
   String toString() => "RefactoringProblemSeverity.$name";
 
   String toJson() => name;
 }
 
 /**
  * RemoveContentOverlay
  *
  * {
  *   "type": "remove"
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RemoveContentOverlay implements HasToJson {
   RemoveContentOverlay();
 
   factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "remove") {
@@ skipping 18 matching lines @@
   bool operator==(other) {
     if (other is RemoveContentOverlay) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, 114870849);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, 114870849);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RequestError
  *
  * {
  *   "code": RequestErrorCode
  *   "message": String
  *   "stackTrace": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RequestError implements HasToJson {
   RequestErrorCode _code;
 
   String _message;
 
   String _stackTrace;
 
   /**
    * A code that uniquely identifies the error that occurred.
@@ skipping 47 matching lines @@
     }
     if (json is Map) {
       RequestErrorCode code;
       if (json.containsKey("code")) {
         code = new RequestErrorCode.fromJson(jsonDecoder, jsonPath + ".code", json["code"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "code");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
+        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       String stackTrace;
       if (json.containsKey("stackTrace")) {
-        stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
+        stackTrace = jsonDecoder.decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
       }
       return new RequestError(code, message, stackTrace: stackTrace);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RequestError", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["code"] = code.toJson();
@@ skipping 13 matching lines @@
       return code == other.code &&
           message == other.message &&
           stackTrace == other.stackTrace;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, code.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, message.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, stackTrace.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, code.hashCode);
+    hash = JenkinsSmiHash.combine(hash, message.hashCode);
+    hash = JenkinsSmiHash.combine(hash, stackTrace.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RequestErrorCode
  *
  * enum {
  *   CONTENT_MODIFIED
  *   FILE_NOT_ANALYZED
  *   FORMAT_INVALID_FILE
@@ skipping 10 matching lines @@
  *   REFACTORING_REQUEST_CANCELLED
  *   SERVER_ALREADY_STARTED
  *   SERVER_ERROR
  *   SORT_MEMBERS_INVALID_FILE
  *   SORT_MEMBERS_PARSE_ERRORS
  *   UNANALYZED_PRIORITY_FILES
  *   UNKNOWN_REQUEST
  *   UNKNOWN_SOURCE
  *   UNSUPPORTED_FEATURE
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RequestErrorCode implements Enum {
   /**
    * An "analysis.getErrors" or "analysis.getNavigation" request could not be
    * satisfied because the content of the file changed before the requested
    * results could be computed.
    */
   static const CONTENT_MODIFIED = const RequestErrorCode._("CONTENT_MODIFIED");
 
   /**
@@ skipping 206 matching lines @@
 
 /**
  * SearchResult
  *
  * {
  *   "location": Location
  *   "kind": SearchResultKind
  *   "isPotential": bool
  *   "path": List<Element>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchResult implements HasToJson {
   Location _location;
 
   SearchResultKind _kind;
 
   bool _isPotential;
 
   List<Element> _path;
 
@@ skipping 78 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "location");
       }
       SearchResultKind kind;
       if (json.containsKey("kind")) {
         kind = new SearchResultKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       bool isPotential;
       if (json.containsKey("isPotential")) {
-        isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["isPotential"]);
+        isPotential = jsonDecoder.decodeBool(jsonPath + ".isPotential", json["isPotential"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isPotential");
       }
       List<Element> path;
       if (json.containsKey("path")) {
-        path = jsonDecoder._decodeList(jsonPath + ".path", json["path"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json));
+        path = jsonDecoder.decodeList(jsonPath + ".path", json["path"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "path");
       }
       return new SearchResult(location, kind, isPotential, path);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SearchResult", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["location"] = location.toJson();
     result["kind"] = kind.toJson();
     result["isPotential"] = isPotential;
     result["path"] = path.map((Element value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchResult) {
       return location == other.location &&
           kind == other.kind &&
           isPotential == other.isPotential &&
-          _listEqual(path, other.path, (Element a, Element b) => a == b);
+          listEqual(path, other.path, (Element a, Element b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, location.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, isPotential.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, path.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, location.hashCode);
+    hash = JenkinsSmiHash.combine(hash, kind.hashCode);
+    hash = JenkinsSmiHash.combine(hash, isPotential.hashCode);
+    hash = JenkinsSmiHash.combine(hash, path.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * SearchResultKind
  *
  * enum {
  *   DECLARATION
  *   INVOCATION
  *   READ
  *   READ_WRITE
  *   REFERENCE
  *   UNKNOWN
  *   WRITE
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SearchResultKind implements Enum {
   /**
    * The declaration of an element.
    */
   static const DECLARATION = const SearchResultKind._("DECLARATION");
 
   /**
    * The invocation of a function or method.
    */
@@ skipping 70 matching lines @@
 
   String toJson() => name;
 }
 
 /**
  * ServerService
  *
  * enum {
  *   STATUS
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ServerService implements Enum {
   static const STATUS = const ServerService._("STATUS");
 
   /**
    * A list containing all of the enum values that are defined.
    */
   static const List<ServerService> VALUES = const <ServerService>[STATUS];
 
   final String name;
@@ skipping 27 matching lines @@
 
 /**
  * SourceChange
  *
  * {
  *   "message": String
  *   "edits": List<SourceFileEdit>
  *   "linkedEditGroups": List<LinkedEditGroup>
  *   "selection": optional Position
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SourceChange implements HasToJson {
   String _message;
 
   List<SourceFileEdit> _edits;
 
   List<LinkedEditGroup> _linkedEditGroups;
 
   Position _selection;
 
@@ skipping 65 matching lines @@
     this.selection = selection;
   }
 
   factory SourceChange.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
+        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       List<SourceFileEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       List<LinkedEditGroup> linkedEditGroups;
       if (json.containsKey("linkedEditGroups")) {
-        linkedEditGroups = jsonDecoder._decodeList(jsonPath + ".linkedEditGroups", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
+        linkedEditGroups = jsonDecoder.decodeList(jsonPath + ".linkedEditGroups", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups");
       }
       Position selection;
       if (json.containsKey("selection")) {
         selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]);
       }
       return new SourceChange(message, edits: edits, linkedEditGroups: linkedEditGroups, selection: selection);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceChange", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["message"] = message;
     result["edits"] = edits.map((SourceFileEdit value) => value.toJson()).toList();
     result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) => value.toJson()).toList();
     if (selection != null) {
       result["selection"] = selection.toJson();
     }
     return result;
   }
 
   /**
    * Adds [edit] to the [FileEdit] for the given [file].
    */
   void addEdit(String file, int fileStamp, SourceEdit edit) =>
-      _addEditToSourceChange(this, file, fileStamp, edit);
+      addEditToSourceChange(this, file, fileStamp, edit);
 
   /**
    * Adds the given [FileEdit].
    */
   void addFileEdit(SourceFileEdit edit) {
     edits.add(edit);
   }
 
   /**
    * Adds the given [LinkedEditGroup].
    */
   void addLinkedEditGroup(LinkedEditGroup linkedEditGroup) {
     linkedEditGroups.add(linkedEditGroup);
   }
 
   /**
    * Returns the [FileEdit] for the given [file], maybe `null`.
    */
   SourceFileEdit getFileEdit(String file) =>
-      _getChangeFileEdit(this, file);
+      getChangeFileEdit(this, file);
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SourceChange) {
       return message == other.message &&
-          _listEqual(edits, other.edits, (SourceFileEdit a, SourceFileEdit b) => a == b) &&
-          _listEqual(linkedEditGroups, other.linkedEditGroups, (LinkedEditGroup a, LinkedEditGroup b) => a == b) &&
+          listEqual(edits, other.edits, (SourceFileEdit a, SourceFileEdit b) => a == b) &&
+          listEqual(linkedEditGroups, other.linkedEditGroups, (LinkedEditGroup a, LinkedEditGroup b) => a == b) &&
           selection == other.selection;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, message.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, linkedEditGroups.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, selection.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, message.hashCode);
+    hash = JenkinsSmiHash.combine(hash, edits.hashCode);
+    hash = JenkinsSmiHash.combine(hash, linkedEditGroups.hashCode);
+    hash = JenkinsSmiHash.combine(hash, selection.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * SourceEdit
  *
  * {
  *   "offset": int
  *   "length": int
  *   "replacement": String
  *   "id": optional String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SourceEdit implements HasToJson {
   /**
    * 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);
+      applySequenceOfEdits(code, edits);
 
   int _offset;
 
   int _length;
 
   String _replacement;
 
   String _id;
 
   /**
@@ skipping 68 matching lines @@
     this.id = id;
   }
 
   factory SourceEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       String replacement;
       if (json.containsKey("replacement")) {
-        replacement = jsonDecoder._decodeString(jsonPath + ".replacement", json["replacement"]);
+        replacement = jsonDecoder.decodeString(jsonPath + ".replacement", json["replacement"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "replacement");
       }
       String id;
       if (json.containsKey("id")) {
-        id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
+        id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       }
       return new SourceEdit(offset, length, replacement, id: id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceEdit", json);
     }
   }
 
   /**
    * The end of the region to be modified.
    */
   int get end => offset + length;
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["replacement"] = replacement;
     if (id != null) {
       result["id"] = id;
     }
     return result;
   }
 
   /**
    * Get the result of applying the edit to the given [code].
    */
-  String apply(String code) => _applyEdit(code, this);
+  String apply(String code) => applyEdit(code, this);
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SourceEdit) {
       return offset == other.offset &&
           length == other.length &&
           replacement == other.replacement &&
           id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, replacement.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, id.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, replacement.hashCode);
+    hash = JenkinsSmiHash.combine(hash, id.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * SourceFileEdit
  *
  * {
  *   "file": FilePath
  *   "fileStamp": long
  *   "edits": List<SourceEdit>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class SourceFileEdit implements HasToJson {
   String _file;
 
   int _fileStamp;
 
   List<SourceEdit> _edits;
 
   /**
    * The file containing the code to be modified.
@@ skipping 52 matching lines @@
     }
   }
 
   factory SourceFileEdit.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"]);
+        file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int fileStamp;
       if (json.containsKey("fileStamp")) {
-        fileStamp = jsonDecoder._decodeInt(jsonPath + ".fileStamp", json["fileStamp"]);
+        fileStamp = jsonDecoder.decodeInt(jsonPath + ".fileStamp", json["fileStamp"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fileStamp");
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       return new SourceFileEdit(file, fileStamp, edits: edits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["fileStamp"] = fileStamp;
     result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
   /**
    * Adds the given [Edit] to the list.
    */
-  void add(SourceEdit edit) => _addEditForSource(this, edit);
+  void add(SourceEdit edit) => addEditForSource(this, edit);
 
   /**
    * Adds the given [Edit]s.
    */
   void addAll(Iterable<SourceEdit> edits) =>
-      _addAllEditsForSource(this, edits);
+      addAllEditsForSource(this, edits);
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SourceFileEdit) {
       return file == other.file &&
           fileStamp == other.fileStamp &&
-          _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
+          listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, fileStamp.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = JenkinsSmiHash.combine(hash, fileStamp.hashCode);
+    hash = JenkinsSmiHash.combine(hash, edits.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * TypeHierarchyItem
  *
  * {
  *   "classElement": Element
  *   "displayName": optional String
  *   "memberElement": optional Element
  *   "superclass": optional int
  *   "interfaces": List<int>
  *   "mixins": List<int>
  *   "subclasses": List<int>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class TypeHierarchyItem implements HasToJson {
   Element _classElement;
 
   String _displayName;
 
   Element _memberElement;
 
   int _superclass;
 
@@ skipping 141 matching lines @@
     }
     if (json is Map) {
       Element classElement;
       if (json.containsKey("classElement")) {
         classElement = new Element.fromJson(jsonDecoder, jsonPath + ".classElement", json["classElement"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "classElement");
       }
       String displayName;
       if (json.containsKey("displayName")) {
-        displayName = jsonDecoder._decodeString(jsonPath + ".displayName", json["displayName"]);
+        displayName = jsonDecoder.decodeString(jsonPath + ".displayName", json["displayName"]);
       }
       Element memberElement;
       if (json.containsKey("memberElement")) {
         memberElement = new Element.fromJson(jsonDecoder, jsonPath + ".memberElement", json["memberElement"]);
       }
       int superclass;
       if (json.containsKey("superclass")) {
-        superclass = jsonDecoder._decodeInt(jsonPath + ".superclass", json["superclass"]);
+        superclass = jsonDecoder.decodeInt(jsonPath + ".superclass", json["superclass"]);
       }
       List<int> interfaces;
       if (json.containsKey("interfaces")) {
-        interfaces = jsonDecoder._decodeList(jsonPath + ".interfaces", json["interfaces"], jsonDecoder._decodeInt);
+        interfaces = jsonDecoder.decodeList(jsonPath + ".interfaces", json["interfaces"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "interfaces");
       }
       List<int> mixins;
       if (json.containsKey("mixins")) {
-        mixins = jsonDecoder._decodeList(jsonPath + ".mixins", json["mixins"], jsonDecoder._decodeInt);
+        mixins = jsonDecoder.decodeList(jsonPath + ".mixins", json["mixins"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "mixins");
       }
       List<int> subclasses;
       if (json.containsKey("subclasses")) {
-        subclasses = jsonDecoder._decodeList(jsonPath + ".subclasses", json["subclasses"], jsonDecoder._decodeInt);
+        subclasses = jsonDecoder.decodeList(jsonPath + ".subclasses", json["subclasses"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subclasses");
       }
       return new TypeHierarchyItem(classElement, displayName: displayName, memberElement: memberElement, superclass: superclass, interfaces: interfaces, mixins: mixins, subclasses: subclasses);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 17 matching lines @@
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is TypeHierarchyItem) {
       return classElement == other.classElement &&
           displayName == other.displayName &&
           memberElement == other.memberElement &&
           superclass == other.superclass &&
-          _listEqual(interfaces, other.interfaces, (int a, int b) => a == b) &&
-          _listEqual(mixins, other.mixins, (int a, int b) => a == b) &&
-          _listEqual(subclasses, other.subclasses, (int a, int b) => a == b);
+          listEqual(interfaces, other.interfaces, (int a, int b) => a == b) &&
+          listEqual(mixins, other.mixins, (int a, int b) => a == b) &&
+          listEqual(subclasses, other.subclasses, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    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);
+    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
+ *
+ * Clients are not expected to subtype this class.
  */
 class ConvertGetterToMethodFeedback {
   @override
   bool operator==(other) {
     if (other is ConvertGetterToMethodFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 616032599;
   }
 }
 /**
  * convertGetterToMethod options
+ *
+ * Clients are not expected to subtype this class.
  */
 class ConvertGetterToMethodOptions {
   @override
   bool operator==(other) {
     if (other is ConvertGetterToMethodOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 488848400;
   }
 }
 /**
  * convertMethodToGetter feedback
+ *
+ * Clients are not expected to subtype this class.
  */
 class ConvertMethodToGetterFeedback {
   @override
   bool operator==(other) {
     if (other is ConvertMethodToGetterFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 165291526;
   }
 }
 /**
  * convertMethodToGetter options
+ *
+ * Clients are not expected to subtype this class.
  */
 class ConvertMethodToGetterOptions {
   @override
   bool operator==(other) {
     if (other is ConvertMethodToGetterOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 27952290;
   }
 }
 
 /**
  * extractLocalVariable feedback
  *
  * {
  *   "coveringExpressionOffsets": List<int>
  *   "coveringExpressionLengths": List<int>
  *   "names": List<String>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExtractLocalVariableFeedback extends RefactoringFeedback implements HasToJson {
   List<int> _coveringExpressionOffsets;
 
   List<int> _coveringExpressionLengths;
 
   List<String> _names;
 
   List<int> _offsets;
 
@@ skipping 84 matching lines @@
     this.lengths = lengths;
   }
 
   factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<int> coveringExpressionOffsets;
       if (json.containsKey("coveringExpressionOffsets")) {
-        coveringExpressionOffsets = jsonDecoder._decodeList(jsonPath + ".coveringExpressionOffsets", json["coveringExpressionOffsets"], jsonDecoder._decodeInt);
+        coveringExpressionOffsets = jsonDecoder.decodeList(jsonPath + ".coveringExpressionOffsets", json["coveringExpressionOffsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "coveringExpressionOffsets");
       }
       List<int> coveringExpressionLengths;
       if (json.containsKey("coveringExpressionLengths")) {
-        coveringExpressionLengths = jsonDecoder._decodeList(jsonPath + ".coveringExpressionLengths", json["coveringExpressionLengths"], jsonDecoder._decodeInt);
+        coveringExpressionLengths = jsonDecoder.decodeList(jsonPath + ".coveringExpressionLengths", json["coveringExpressionLengths"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "coveringExpressionLengths");
       }
       List<String> names;
       if (json.containsKey("names")) {
-        names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], jsonDecoder._decodeString);
+        names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "names");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
-        offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
+        offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offsets");
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
-        lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
+        lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "lengths");
       }
       return new ExtractLocalVariableFeedback(coveringExpressionOffsets, coveringExpressionLengths, names, offsets, lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["coveringExpressionOffsets"] = coveringExpressionOffsets;
     result["coveringExpressionLengths"] = coveringExpressionLengths;
     result["names"] = names;
     result["offsets"] = offsets;
     result["lengths"] = lengths;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExtractLocalVariableFeedback) {
-      return _listEqual(coveringExpressionOffsets, other.coveringExpressionOffsets, (int a, int b) => a == b) &&
-          _listEqual(coveringExpressionLengths, other.coveringExpressionLengths, (int a, int b) => a == b) &&
-          _listEqual(names, other.names, (String a, String b) => a == b) &&
-          _listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
-          _listEqual(lengths, other.lengths, (int a, int b) => a == b);
+      return listEqual(coveringExpressionOffsets, other.coveringExpressionOffsets, (int a, int b) => a == b) &&
+          listEqual(coveringExpressionLengths, other.coveringExpressionLengths, (int a, int b) => a == b) &&
+          listEqual(names, other.names, (String a, String b) => a == b) &&
+          listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
+          listEqual(lengths, other.lengths, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, coveringExpressionOffsets.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, coveringExpressionLengths.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, names.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offsets.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, lengths.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, coveringExpressionOffsets.hashCode);
+    hash = JenkinsSmiHash.combine(hash, coveringExpressionLengths.hashCode);
+    hash = JenkinsSmiHash.combine(hash, names.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offsets.hashCode);
+    hash = JenkinsSmiHash.combine(hash, lengths.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * extractLocalVariable options
  *
  * {
  *   "name": String
  *   "extractAll": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExtractLocalVariableOptions extends RefactoringOptions implements HasToJson {
   String _name;
 
   bool _extractAll;
 
   /**
    * The name that the local variable should be given.
    */
   String get name => _name;
@@ skipping 30 matching lines @@
     this.extractAll = extractAll;
   }
 
   factory ExtractLocalVariableOptions.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"]);
+        name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
-        extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
+        extractAll = jsonDecoder.decodeBool(jsonPath + ".extractAll", json["extractAll"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "extractAll");
       }
       return new ExtractLocalVariableOptions(name, extractAll);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable options", json);
     }
   }
 
   factory ExtractLocalVariableOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
@@ skipping 16 matching lines @@
     if (other is ExtractLocalVariableOptions) {
       return name == other.name &&
           extractAll == other.extractAll;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, name.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, extractAll.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, name.hashCode);
+    hash = JenkinsSmiHash.combine(hash, extractAll.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * extractMethod feedback
  *
  * {
  *   "offset": int
  *   "length": int
  *   "returnType": String
  *   "names": List<String>
  *   "canCreateGetter": bool
  *   "parameters": List<RefactoringMethodParameter>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExtractMethodFeedback extends RefactoringFeedback implements HasToJson {
   int _offset;
 
   int _length;
 
   String _returnType;
 
   List<String> _names;
 
@@ skipping 134 matching lines @@
     this.lengths = lengths;
   }
 
   factory ExtractMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "returnType");
       }
       List<String> names;
       if (json.containsKey("names")) {
-        names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], jsonDecoder._decodeString);
+        names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "names");
       }
       bool canCreateGetter;
       if (json.containsKey("canCreateGetter")) {
-        canCreateGetter = jsonDecoder._decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]);
+        canCreateGetter = jsonDecoder.decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "canCreateGetter");
       }
       List<RefactoringMethodParameter> parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
+        parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "parameters");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
-        offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
+        offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offsets");
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
-        lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
+        lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "lengths");
       }
       return new ExtractMethodFeedback(offset, length, returnType, names, canCreateGetter, parameters, offsets, lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 11 matching lines @@
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExtractMethodFeedback) {
       return offset == other.offset &&
           length == other.length &&
           returnType == other.returnType &&
-          _listEqual(names, other.names, (String a, String b) => a == b) &&
+          listEqual(names, other.names, (String a, String b) => a == b) &&
           canCreateGetter == other.canCreateGetter &&
-          _listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
-          _listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
-          _listEqual(lengths, other.lengths, (int a, int b) => a == b);
+          listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
+          listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
+          listEqual(lengths, other.lengths, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, names.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, canCreateGetter.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, offsets.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, lengths.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, returnType.hashCode);
+    hash = JenkinsSmiHash.combine(hash, names.hashCode);
+    hash = JenkinsSmiHash.combine(hash, canCreateGetter.hashCode);
+    hash = JenkinsSmiHash.combine(hash, parameters.hashCode);
+    hash = JenkinsSmiHash.combine(hash, offsets.hashCode);
+    hash = JenkinsSmiHash.combine(hash, lengths.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * extractMethod options
  *
  * {
  *   "returnType": String
  *   "createGetter": bool
  *   "name": String
  *   "parameters": List<RefactoringMethodParameter>
  *   "extractAll": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class ExtractMethodOptions extends RefactoringOptions implements HasToJson {
   String _returnType;
 
   bool _createGetter;
 
   String _name;
 
   List<RefactoringMethodParameter> _parameters;
 
@@ skipping 96 matching lines @@
     this.extractAll = extractAll;
   }
 
   factory ExtractMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "returnType");
       }
       bool createGetter;
       if (json.containsKey("createGetter")) {
-        createGetter = jsonDecoder._decodeBool(jsonPath + ".createGetter", json["createGetter"]);
+        createGetter = jsonDecoder.decodeBool(jsonPath + ".createGetter", json["createGetter"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "createGetter");
       }
       String name;
       if (json.containsKey("name")) {
-        name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
+        name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       List<RefactoringMethodParameter> parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
+        parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "parameters");
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
-        extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
+        extractAll = jsonDecoder.decodeBool(jsonPath + ".extractAll", json["extractAll"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "extractAll");
       }
       return new ExtractMethodOptions(returnType, createGetter, name, parameters, extractAll);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod options", json);
     }
   }
 
   factory ExtractMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
@@ skipping 13 matching lines @@
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExtractMethodOptions) {
       return returnType == other.returnType &&
           createGetter == other.createGetter &&
           name == other.name &&
-          _listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
+          listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
           extractAll == other.extractAll;
     }
     return false;
   }
 
   @override
   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);
+    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
  *
  * {
  *   "name": String
  *   "occurrences": int
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class InlineLocalVariableFeedback extends RefactoringFeedback implements HasToJson {
   String _name;
 
   int _occurrences;
 
   /**
    * The name of the variable being inlined.
    */
   String get name => _name;
@@ skipping 24 matching lines @@
     this.occurrences = occurrences;
   }
 
   factory InlineLocalVariableFeedback.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"]);
+        name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       int occurrences;
       if (json.containsKey("occurrences")) {
-        occurrences = jsonDecoder._decodeInt(jsonPath + ".occurrences", json["occurrences"]);
+        occurrences = jsonDecoder.decodeInt(jsonPath + ".occurrences", json["occurrences"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "occurrences");
       }
       return new InlineLocalVariableFeedback(name, occurrences);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "inlineLocalVariable feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 11 matching lines @@
     if (other is InlineLocalVariableFeedback) {
       return name == other.name &&
           occurrences == other.occurrences;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, name.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, occurrences.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, name.hashCode);
+    hash = JenkinsSmiHash.combine(hash, occurrences.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * inlineLocalVariable options
+ *
+ * Clients are not expected to subtype this class.
  */
 class InlineLocalVariableOptions {
   @override
   bool operator==(other) {
     if (other is InlineLocalVariableOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 540364977;
   }
 }
 
 /**
  * inlineMethod feedback
  *
  * {
  *   "className": optional String
  *   "methodName": String
  *   "isDeclaration": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class InlineMethodFeedback extends RefactoringFeedback implements HasToJson {
   String _className;
 
   String _methodName;
 
   bool _isDeclaration;
 
   /**
    * The name of the class enclosing the method being inlined. If not a class
@@ skipping 43 matching lines @@
     this.isDeclaration = isDeclaration;
   }
 
   factory InlineMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String className;
       if (json.containsKey("className")) {
-        className = jsonDecoder._decodeString(jsonPath + ".className", json["className"]);
+        className = jsonDecoder.decodeString(jsonPath + ".className", json["className"]);
       }
       String methodName;
       if (json.containsKey("methodName")) {
-        methodName = jsonDecoder._decodeString(jsonPath + ".methodName", json["methodName"]);
+        methodName = jsonDecoder.decodeString(jsonPath + ".methodName", json["methodName"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "methodName");
       }
       bool isDeclaration;
       if (json.containsKey("isDeclaration")) {
-        isDeclaration = jsonDecoder._decodeBool(jsonPath + ".isDeclaration", json["isDeclaration"]);
+        isDeclaration = jsonDecoder.decodeBool(jsonPath + ".isDeclaration", json["isDeclaration"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isDeclaration");
       }
       return new InlineMethodFeedback(methodName, isDeclaration, className: className);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "inlineMethod feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 15 matching lines @@
       return className == other.className &&
           methodName == other.methodName &&
           isDeclaration == other.isDeclaration;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, className.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, methodName.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, isDeclaration.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, className.hashCode);
+    hash = JenkinsSmiHash.combine(hash, methodName.hashCode);
+    hash = JenkinsSmiHash.combine(hash, isDeclaration.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * inlineMethod options
  *
  * {
  *   "deleteSource": bool
  *   "inlineAll": bool
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class InlineMethodOptions extends RefactoringOptions implements HasToJson {
   bool _deleteSource;
 
   bool _inlineAll;
 
   /**
    * True if the method being inlined should be removed. It is an error if this
    * field is true and inlineAll is false.
    */
@@ skipping 28 matching lines @@
     this.inlineAll = inlineAll;
   }
 
   factory InlineMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool deleteSource;
       if (json.containsKey("deleteSource")) {
-        deleteSource = jsonDecoder._decodeBool(jsonPath + ".deleteSource", json["deleteSource"]);
+        deleteSource = jsonDecoder.decodeBool(jsonPath + ".deleteSource", json["deleteSource"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "deleteSource");
       }
       bool inlineAll;
       if (json.containsKey("inlineAll")) {
-        inlineAll = jsonDecoder._decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
+        inlineAll = jsonDecoder.decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "inlineAll");
       }
       return new InlineMethodOptions(deleteSource, inlineAll);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "inlineMethod options", json);
     }
   }
 
   factory InlineMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
@@ skipping 16 matching lines @@
     if (other is InlineMethodOptions) {
       return deleteSource == other.deleteSource &&
           inlineAll == other.inlineAll;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, deleteSource.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, inlineAll.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, deleteSource.hashCode);
+    hash = JenkinsSmiHash.combine(hash, inlineAll.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 /**
  * moveFile feedback
+ *
+ * Clients are not expected to subtype this class.
  */
 class MoveFileFeedback {
   @override
   bool operator==(other) {
     if (other is MoveFileFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 438975893;
   }
 }
 
 /**
  * moveFile options
  *
  * {
  *   "newFile": FilePath
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class MoveFileOptions extends RefactoringOptions implements HasToJson {
   String _newFile;
 
   /**
    * The new file path to which the given file is being moved.
    */
   String get newFile => _newFile;
 
   /**
    * The new file path to which the given file is being moved.
    */
   void set newFile(String value) {
     assert(value != null);
     this._newFile = value;
   }
 
   MoveFileOptions(String newFile) {
     this.newFile = newFile;
   }
 
   factory MoveFileOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String newFile;
       if (json.containsKey("newFile")) {
-        newFile = jsonDecoder._decodeString(jsonPath + ".newFile", json["newFile"]);
+        newFile = jsonDecoder.decodeString(jsonPath + ".newFile", json["newFile"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "newFile");
       }
       return new MoveFileOptions(newFile);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "moveFile options", json);
     }
   }
 
   factory MoveFileOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
@@ skipping 14 matching lines @@
   bool operator==(other) {
     if (other is MoveFileOptions) {
       return newFile == other.newFile;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, newFile.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, newFile.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * rename feedback
  *
  * {
  *   "offset": int
  *   "length": int
  *   "elementKindName": String
  *   "oldName": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RenameFeedback extends RefactoringFeedback implements HasToJson {
   int _offset;
 
   int _length;
 
   String _elementKindName;
 
   String _oldName;
 
@@ skipping 58 matching lines @@
     this.oldName = oldName;
   }
 
   factory RenameFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
-        offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
+        offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
-        length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
+        length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       String elementKindName;
       if (json.containsKey("elementKindName")) {
-        elementKindName = jsonDecoder._decodeString(jsonPath + ".elementKindName", json["elementKindName"]);
+        elementKindName = jsonDecoder.decodeString(jsonPath + ".elementKindName", json["elementKindName"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "elementKindName");
       }
       String oldName;
       if (json.containsKey("oldName")) {
-        oldName = jsonDecoder._decodeString(jsonPath + ".oldName", json["oldName"]);
+        oldName = jsonDecoder.decodeString(jsonPath + ".oldName", json["oldName"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "oldName");
       }
       return new RenameFeedback(offset, length, elementKindName, oldName);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "rename feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
@@ skipping 15 matching lines @@
           length == other.length &&
           elementKindName == other.elementKindName &&
           oldName == other.oldName;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, length.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, elementKindName.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, oldName.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, offset.hashCode);
+    hash = JenkinsSmiHash.combine(hash, length.hashCode);
+    hash = JenkinsSmiHash.combine(hash, elementKindName.hashCode);
+    hash = JenkinsSmiHash.combine(hash, oldName.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * rename options
  *
  * {
  *   "newName": String
  * }
+ *
+ * Clients are not expected to subtype this class.
  */
 class RenameOptions extends RefactoringOptions implements HasToJson {
   String _newName;
 
   /**
    * The name that the element should have after the refactoring.
    */
   String get newName => _newName;
 
   /**
    * The name that the element should have after the refactoring.
    */
   void set newName(String value) {
     assert(value != null);
     this._newName = value;
   }
 
   RenameOptions(String newName) {
     this.newName = newName;
   }
 
   factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String newName;
       if (json.containsKey("newName")) {
-        newName = jsonDecoder._decodeString(jsonPath + ".newName", json["newName"]);
+        newName = jsonDecoder.decodeString(jsonPath + ".newName", json["newName"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "newName");
       }
       return new RenameOptions(newName);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "rename options", json);
     }
   }
 
   factory RenameOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
@@ skipping 14 matching lines @@
   bool operator==(other) {
     if (other is RenameOptions) {
       return newName == other.newName;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
-    return _JenkinsSmiHash.finish(hash);
+    hash = JenkinsSmiHash.combine(hash, newName.hashCode);
+    return JenkinsSmiHash.finish(hash);
   }
 }