Api-roll 43: 2016-12-13

generated/googleapis/lib/vision/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.vision.v1;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 109 matching lines @@
       _json["imageContext"] = (imageContext).toJson();
     }
     return _json;
   }
 }
 
 /** Response to an image annotation request. */
 class AnnotateImageResponse {
   /**
    * If set, represents the error message for the operation.
-   * Note that filled-in mage annotations are guaranteed to be
-   * correct, even when <code>error</code> is non-empty.
+   * Note that filled-in image annotations are guaranteed to be
+   * correct, even when `error` is set.
    */
   Status error;
-  /** If present, face detection completed successfully. */
+  /** If present, face detection has completed successfully. */
   core.List<FaceAnnotation> faceAnnotations;
   /** If present, image properties were extracted successfully. */
   ImageProperties imagePropertiesAnnotation;
-  /** If present, label detection completed successfully. */
+  /** If present, label detection has completed successfully. */
   core.List<EntityAnnotation> labelAnnotations;
-  /** If present, landmark detection completed successfully. */
+  /** If present, landmark detection has completed successfully. */
   core.List<EntityAnnotation> landmarkAnnotations;
-  /** If present, logo detection completed successfully. */
+  /** If present, logo detection has completed successfully. */
   core.List<EntityAnnotation> logoAnnotations;
-  /** If present, safe-search annotation completed successfully. */
+  /** If present, safe-search annotation has completed successfully. */
   SafeSearchAnnotation safeSearchAnnotation;
-  /** If present, text (OCR) detection completed successfully. */
+  /** If present, text (OCR) detection has completed successfully. */
   core.List<EntityAnnotation> textAnnotations;
 
   AnnotateImageResponse();
 
   AnnotateImageResponse.fromJson(core.Map _json) {
     if (_json.containsKey("error")) {
       error = new Status.fromJson(_json["error"]);
     }
     if (_json.containsKey("faceAnnotations")) {
       faceAnnotations = _json["faceAnnotations"].map((value) => new FaceAnnotation.fromJson(value)).toList();
@@ skipping 283 matching lines @@
       _json["green"] = green;
     }
     if (red != null) {
       _json["red"] = red;
     }
     return _json;
   }
 }
 
 /**
- * Color information consists of RGB channels, score and fraction of
- * image the color occupies in the image.
+ * Color information consists of RGB channels, score, and the fraction of
+ * the image that the color occupies in the image.
  */
 class ColorInfo {
   /** RGB components of the color. */
   Color color;
   /**
-   * Stores the fraction of pixels the color occupies in the image.
+   * The fraction of pixels the color occupies in the image.
    * Value in range [0, 1].
    */
   core.double pixelFraction;
   /** Image-specific score for this color. Value in range [0, 1]. */
   core.double score;
 
   ColorInfo();
 
   ColorInfo.fromJson(core.Map _json) {
     if (_json.containsKey("color")) {
@@ skipping 17 matching lines @@
     }
     if (score != null) {
       _json["score"] = score;
     }
     return _json;
   }
 }
 
 /** Set of dominant colors and their corresponding scores. */
 class DominantColorsAnnotation {
-  /** RGB color values, with their score and pixel fraction. */
+  /** RGB color values with their score and pixel fraction. */
   core.List<ColorInfo> colors;
 
   DominantColorsAnnotation();
 
   DominantColorsAnnotation.fromJson(core.Map _json) {
     if (_json.containsKey("colors")) {
       colors = _json["colors"].map((value) => new ColorInfo.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (colors != null) {
       _json["colors"] = colors.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Set of detected entity features. */
 class EntityAnnotation {
   /**
-   * Image region to which this entity belongs. Not filled currently
+   * Image region to which this entity belongs. Currently not produced
    * for `LABEL_DETECTION` features. For `TEXT_DETECTION` (OCR), `boundingPoly`s
    * are produced for the entire text detected in an image region, followed by
    * `boundingPoly`s for each word within the detected text.
    */
   BoundingPoly boundingPoly;
   /**
    * The accuracy of the entity detection in an image.
-   * For example, for an image containing 'Eiffel Tower,' this field represents
-   * the confidence that there is a tower in the query image. Range [0, 1].
+   * For example, for an image in which the "Eiffel Tower" entity is detected,
+   * this field represents the confidence that there is a tower in the query
+   * image. Range [0, 1].
    */
   core.double confidence;
-  /**
-   * Entity textual description, expressed in its <code>locale</code> language.
-   */
+  /** Entity textual description, expressed in its `locale` language. */
   core.String description;
   /**
    * The language code for the locale in which the entity textual
-   * <code>description</code> (next field) is expressed.
+   * `description` is expressed.
    */
   core.String locale;
   /**
    * The location information for the detected entity. Multiple
-   * <code>LocationInfo</code> elements can be present since one location may
-   * indicate the location of the scene in the query image, and another the
-   * location of the place where the query image was taken. Location information
-   * is usually present for landmarks.
+   * `LocationInfo` elements can be present because one location may
+   * indicate the location of the scene in the image, and another location
+   * may indicate the location of the place where the image was taken.
+   * Location information is usually present for landmarks.
    */
   core.List<LocationInfo> locations;
   /**
-   * Opaque entity ID. Some IDs might be available in Knowledge Graph(KG).
-   * For more details on KG please see:
-   * https://developers.google.com/knowledge-graph/
+   * Opaque entity ID. Some IDs may be available in
+   * [Google Knowledge Graph Search
+   * API](https://developers.google.com/knowledge-graph/).
    */
   core.String mid;
   /**
-   * Some entities can have additional optional <code>Property</code> fields.
-   * For example a different kind of score or string that qualifies the entity.
+   * Some entities may have optional user-supplied `Property` (name/value)
+   * fields, such a score or string that qualifies the entity.
    */
   core.List<Property> properties;
   /** Overall score of the result. Range [0, 1]. */
   core.double score;
   /**
    * The relevancy of the ICA (Image Content Annotation) label to the
-   * image. For example, the relevancy of 'tower' to an image containing
-   * 'Eiffel Tower' is likely higher than an image containing a distant towering
-   * building, though the confidence that there is a tower may be the same.
-   * Range [0, 1].
+   * image. For example, the relevancy of "tower" is likely higher to an image
+   * containing the detected "Eiffel Tower" than to an image containing a
+   * detected distant towering building, even though the confidence that
+   * there is a tower in each image may be the same. Range [0, 1].
    */
   core.double topicality;
 
   EntityAnnotation();
 
   EntityAnnotation.fromJson(core.Map _json) {
     if (_json.containsKey("boundingPoly")) {
       boundingPoly = new BoundingPoly.fromJson(_json["boundingPoly"]);
     }
     if (_json.containsKey("confidence")) {
@@ skipping 54 matching lines @@
     return _json;
   }
 }
 
 /** A face annotation object contains the results of face detection. */
 class FaceAnnotation {
   /**
    * Anger likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String angerLikelihood;
   /**
    * Blurred likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String blurredLikelihood;
   /**
    * The bounding polygon around the face. The coordinates of the bounding box
-   * are in the original image's scale, as returned in ImageParams.
+   * are in the original image's scale, as returned in `ImageParams`.
    * The bounding box is computed to "frame" the face in accordance with human
    * expectations. It is based on the landmarker results.
    * Note that one or more x and/or y coordinates may not be generated in the
-   * BoundingPoly (the polygon will be unbounded) if only a partial face appears
-   * in
-   * the image to be annotated.
+   * `BoundingPoly` (the polygon will be unbounded) if only a partial face
+   * appears in the image to be annotated.
    */
   BoundingPoly boundingPoly;
   /** Detection confidence. Range [0, 1]. */
   core.double detectionConfidence;
   /**
-   * This bounding polygon is tighter than the previous
-   * <code>boundingPoly</code>, and
-   * encloses only the skin part of the face. Typically, it is used to
-   * eliminate the face from any image analysis that detects the
+   * The `fd_bounding_poly` bounding polygon is tighter than the
+   * `boundingPoly`, and encloses only the skin part of the face. Typically, it
+   * is used to eliminate the face from any image analysis that detects the
    * "amount of skin" visible in an image. It is not based on the
    * landmarker results, only on the initial face detection, hence
    * the <code>fd</code> (face detection) prefix.
    */
   BoundingPoly fdBoundingPoly;
   /**
    * Headwear likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String headwearLikelihood;
   /**
    * Joy likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String joyLikelihood;
   /** Face landmarking confidence. Range [0, 1]. */
   core.double landmarkingConfidence;
   /** Detected face landmarks. */
   core.List<Landmark> landmarks;
   /**
-   * Yaw angle. Indicates the leftward/rightward angle that the face is
-   * pointing, relative to the vertical plane perpendicular to the image. Range
+   * Yaw angle, which indicates the leftward/rightward angle that the face is
+   * pointing relative to the vertical plane perpendicular to the image. Range
    * [-180,180].
    */
   core.double panAngle;
   /**
-   * Roll angle. Indicates the amount of clockwise/anti-clockwise rotation of
-   * the
-   * face relative to the image vertical, about the axis perpendicular to the
-   * face. Range [-180,180].
+   * Roll angle, which indicates the amount of clockwise/anti-clockwise rotation
+   * of the face relative to the image vertical about the axis perpendicular to
+   * the face. Range [-180,180].
    */
   core.double rollAngle;
   /**
    * Sorrow likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String sorrowLikelihood;
   /**
    * Surprise likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String surpriseLikelihood;
   /**
-   * Pitch angle. Indicates the upwards/downwards angle that the face is
-   * pointing
-   * relative to the image's horizontal plane. Range [-180,180].
+   * Pitch angle, which indicates the upwards/downwards angle that the face is
+   * pointing relative to the image's horizontal plane. Range [-180,180].
    */
   core.double tiltAngle;
   /**
    * Under-exposed likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String underExposedLikelihood;
 
   FaceAnnotation();
 
   FaceAnnotation.fromJson(core.Map _json) {
     if (_json.containsKey("angerLikelihood")) {
       angerLikelihood = _json["angerLikelihood"];
     }
     if (_json.containsKey("blurredLikelihood")) {
@@ skipping 85 matching lines @@
       _json["tiltAngle"] = tiltAngle;
     }
     if (underExposedLikelihood != null) {
       _json["underExposedLikelihood"] = underExposedLikelihood;
     }
     return _json;
   }
 }
 
 /**
- * The <em>Feature</em> indicates what type of image detection task to perform.
  * Users describe the type of Google Cloud Vision API tasks to perform over
- * images by using <em>Feature</em>s. Features encode the Cloud Vision API
+ * images by using *Feature*s. Each Feature indicates a type of image
+ * detection task to perform. Features encode the Cloud Vision API
  * vertical to operate on and the number of top-scoring results to return.
  */
 class Feature {
   /** Maximum number of results of this type. */
   core.int maxResults;
   /**
    * The feature type.
    * Possible string values are:
    * - "TYPE_UNSPECIFIED" : Unspecified feature type.
    * - "FACE_DETECTION" : Run face detection.
    * - "LANDMARK_DETECTION" : Run landmark detection.
    * - "LOGO_DETECTION" : Run logo detection.
    * - "LABEL_DETECTION" : Run label detection.
    * - "TEXT_DETECTION" : Run OCR.
-   * - "SAFE_SEARCH_DETECTION" : Run various computer vision models to compute
-   * image safe-search properties.
-   * - "IMAGE_PROPERTIES" : Compute a set of properties about the image (such as
-   * the image's dominant colors).
+   * - "SAFE_SEARCH_DETECTION" : Run computer vision models to compute image
+   * safe-search properties.
+   * - "IMAGE_PROPERTIES" : Compute a set of image properties, such as the
+   * image's dominant colors.
    */
   core.String type;
 
   Feature();
 
   Feature.fromJson(core.Map _json) {
     if (_json.containsKey("maxResults")) {
       maxResults = _json["maxResults"];
     }
     if (_json.containsKey("type")) {
@@ skipping 22 matching lines @@
    */
   core.String content;
   core.List<core.int> get contentAsBytes {
     return convert.BASE64.decode(content);
   }
 
   void set contentAsBytes(core.List<core.int> _bytes) {
     content = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
-   * Google Cloud Storage image location. If both 'content' and 'source'
-   * are filled for an image, 'content' takes precedence and it will be
-   * used for performing the image annotation request.
+   * Google Cloud Storage image location. If both `content` and `source`
+   * are provided for an image, `content` takes precedence and is
+   * used to perform the image annotation request.
    */
   ImageSource source;
 
   Image();
 
   Image.fromJson(core.Map _json) {
     if (_json.containsKey("content")) {
       content = _json["content"];
     }
     if (_json.containsKey("source")) {
@@ skipping 16 matching lines @@
 /** Image context and/or feature-specific parameters. */
 class ImageContext {
   /**
    * List of languages to use for TEXT_DETECTION. In most cases, an empty value
    * yields the best results since it enables automatic language detection. For
    * languages based on the Latin alphabet, setting `language_hints` is not
    * needed. In rare cases, when the language of the text in the image is known,
    * setting a hint will help get better results (although it will be a
    * significant hindrance if the hint is wrong). Text detection returns an
    * error if one or more of the specified languages is not one of the
-   * [supported
-   * languages](/translate/v2/translate-reference#supported_languages).
+   * [supported languages](/vision/docs/languages).
    */
   core.List<core.String> languageHints;
-  /** Lat/long rectangle that specifies the location of the image. */
+  /** lat/long rectangle that specifies the location of the image. */
   LatLongRect latLongRect;
 
   ImageContext();
 
   ImageContext.fromJson(core.Map _json) {
     if (_json.containsKey("languageHints")) {
       languageHints = _json["languageHints"];
     }
     if (_json.containsKey("latLongRect")) {
       latLongRect = new LatLongRect.fromJson(_json["latLongRect"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (languageHints != null) {
       _json["languageHints"] = languageHints;
     }
     if (latLongRect != null) {
       _json["latLongRect"] = (latLongRect).toJson();
     }
     return _json;
   }
 }
 
-/** Stores image properties (e.g. dominant colors). */
+/** Stores image properties, such as dominant colors. */
 class ImageProperties {
   /** If present, dominant colors completed successfully. */
   DominantColorsAnnotation dominantColors;
 
   ImageProperties();
 
   ImageProperties.fromJson(core.Map _json) {
     if (_json.containsKey("dominantColors")) {
       dominantColors = new DominantColorsAnnotation.fromJson(_json["dominantColors"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dominantColors != null) {
       _json["dominantColors"] = (dominantColors).toJson();
     }
     return _json;
   }
 }
 
 /** External image source (Google Cloud Storage image location). */
 class ImageSource {
   /**
-   * Google Cloud Storage image URI. It must be in the following form:
-   * `gs://bucket_name/object_name`. For more
-   * details, please see: https://cloud.google.com/storage/docs/reference-uris.
-   * NOTE: Cloud Storage object versioning is not supported!
+   * Google Cloud Storage image URI, which must be in the following form:
+   * `gs://bucket_name/object_name` (for details, see
+   * [Google Cloud Storage Request
+   * URIs](https://cloud.google.com/storage/docs/reference-uris)).
+   * NOTE: Cloud Storage object versioning is not supported.
    */
   core.String gcsImageUri;
 
   ImageSource();
 
   ImageSource.fromJson(core.Map _json) {
     if (_json.containsKey("gcsImageUri")) {
       gcsImageUri = _json["gcsImageUri"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (gcsImageUri != null) {
       _json["gcsImageUri"] = gcsImageUri;
     }
     return _json;
   }
 }
 
 /**
  * A face-specific landmark (for example, a face feature).
  * Landmark positions may fall outside the bounds of the image
- * when the face is near one or more edges of the image.
- * Therefore it is NOT guaranteed that 0 <= x < width or 0 <= y < height.
+ * if the face is near one or more edges of the image.
+ * Therefore it is NOT guaranteed that `0 <= x < width` or
+ * `0 <= y < height`.
  */
 class Landmark {
   /** Face landmark position. */
   Position position;
   /**
    * Face landmark type.
    * Possible string values are:
    * - "UNKNOWN_LANDMARK" : Unknown face landmark detected. Should not be
    * filled.
    * - "LEFT_EYE" : Left eye.
@@ skipping 119 matching lines @@
     if (latitude != null) {
       _json["latitude"] = latitude;
     }
     if (longitude != null) {
       _json["longitude"] = longitude;
     }
     return _json;
   }
 }
 
-/** Rectangle determined by min and max LatLng pairs. */
+/** Rectangle determined by min and max `LatLng` pairs. */
 class LatLongRect {
   /** Max lat/long pair. */
   LatLng maxLatLng;
   /** Min lat/long pair. */
   LatLng minLatLng;
 
   LatLongRect();
 
   LatLongRect.fromJson(core.Map _json) {
     if (_json.containsKey("maxLatLng")) {
@@ skipping 11 matching lines @@
     }
     if (minLatLng != null) {
       _json["minLatLng"] = (minLatLng).toJson();
     }
     return _json;
   }
 }
 
 /** Detected entity location information. */
 class LocationInfo {
-  /** Lat - long location coordinates. */
+  /** lat/long location coordinates. */
   LatLng latLng;
 
   LocationInfo();
 
   LocationInfo.fromJson(core.Map _json) {
     if (_json.containsKey("latLng")) {
       latLng = new LatLng.fromJson(_json["latLng"]);
     }
   }
 
@@ skipping 41 matching lines @@
     if (y != null) {
       _json["y"] = y;
     }
     if (z != null) {
       _json["z"] = z;
     }
     return _json;
   }
 }
 
-/** Arbitrary name/value pair. */
+/** A `Property` consists of a user-supplied name/value pair. */
 class Property {
   /** Name of the property. */
   core.String name;
   /** Value of the property. */
   core.String value;
 
   Property();
 
   Property.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
     if (_json.containsKey("value")) {
       value = _json["value"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (name != null) {
       _json["name"] = name;
     }
     if (value != null) {
       _json["value"] = value;
     }
     return _json;
   }
 }
 
-/**
- * Set of features pertaining to the image, computed by various computer vision
- * methods over safe-search verticals (for example, adult, spoof, medical,
- * violence).
- */
 class SafeSearchAnnotation {
   /**
-   * Represents the adult contents likelihood for the image.
+   * Represents the adult content likelihood for the image.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String adult;
   /**
-   * Likelihood this is a medical image.
+   * Likelihood that this is a medical image.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String medical;
   /**
-   * Spoof likelihood. The likelihood that an obvious modification
+   * Spoof likelihood. The likelihood that an modification
    * was made to the image's canonical version to make it appear
    * funny or offensive.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String spoof;
   /**
    * Violence likelihood.
    * Possible string values are:
    * - "UNKNOWN" : Unknown likelihood.
-   * - "VERY_UNLIKELY" : The image very unlikely belongs to the vertical
-   * specified.
-   * - "UNLIKELY" : The image unlikely belongs to the vertical specified.
-   * - "POSSIBLE" : The image possibly belongs to the vertical specified.
-   * - "LIKELY" : The image likely belongs to the vertical specified.
-   * - "VERY_LIKELY" : The image very likely belongs to the vertical specified.
+   * - "VERY_UNLIKELY" : It is very unlikely that the image belongs to the
+   * specified vertical.
+   * - "UNLIKELY" : It is unlikely that the image belongs to the specified
+   * vertical.
+   * - "POSSIBLE" : It is possible that the image belongs to the specified
+   * vertical.
+   * - "LIKELY" : It is likely that the image belongs to the specified vertical.
+   * - "VERY_LIKELY" : It is very likely that the image belongs to the specified
+   * vertical.
    */
   core.String violence;
 
   SafeSearchAnnotation();
 
   SafeSearchAnnotation.fromJson(core.Map _json) {
     if (_json.containsKey("adult")) {
       adult = _json["adult"];
     }
     if (_json.containsKey("medical")) {
@@ skipping 153 matching lines @@
     var _json = new core.Map();
     if (x != null) {
       _json["x"] = x;
     }
     if (y != null) {
       _json["y"] = y;
     }
     return _json;
   }
 }