..

backend/node_modules/googleapis/apis/vision/v1.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* jshint maxlen: false */
+const apirequest_1 = require("../../lib/apirequest");
+/**
+ * Google Cloud Vision API
+ *
+ * Integrates Google Vision features, including image labeling, face, logo, and landmark detection, optical character recognition (OCR), and detection of explicit content, into applications.
+ *
+ * @example
+ * const google = require('googleapis');
+ * const vision = google.vision('v1');
+ *
+ * @namespace vision
+ * @type {Function}
+ * @version v1
+ * @variation v1
+ * @param {object=} options Options for Vision
+ */
+function Vision(options) {
+    const self = this;
+    self._options = options || {};
+    self.images = {
+        /**
+         * vision.images.annotate
+         *
+         * @desc Run image detection and annotation for a batch of images.
+         *
+         * @example
+         * // BEFORE RUNNING:
+         * // ---------------
+         * // 1. If not already done, enable the Google Cloud Vision API
+         * //    and check the quota for your project at
+         * //    https://console.developers.google.com/apis/api/vision
+         * // 2. This sample uses Application Default Credentials for authentication.
+         * //    If not already done, install the gcloud CLI from
+         * //    https://cloud.google.com/sdk and run
+         * //    `gcloud beta auth application-default login`.
+         * //    For more information, see
+         * //    https://developers.google.com/identity/protocols/application-default-credentials
+         * // 3. Install the Node.js client library by running
+         * //    `npm install googleapis --save`
+         *
+         * var google = require('googleapis');
+         * var vision = google.vision('v1');
+         *
+         * authorize(function(authClient) {
+         *   var request = {
+         *     resource: {
+         *       // TODO: Add desired properties to the request body.
+         *     },
+         *
+         *     auth: authClient,
+         *   };
+         *
+         *   vision.images.annotate(request, function(err, response) {
+         *     if (err) {
+         *       console.error(err);
+         *       return;
+         *     }
+         *
+         *     // TODO: Change code below to process the `response` object:
+         *     console.log(JSON.stringify(response, null, 2));
+         *   });
+         * });
+         *
+         * function authorize(callback) {
+         *   google.auth.getApplicationDefault(function(err, authClient) {
+         *     if (err) {
+         *       console.error('authentication failed: ', err);
+         *       return;
+         *     }
+         *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
+         *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
+         *       authClient = authClient.createScoped(scopes);
+         *     }
+         *     callback(authClient);
+         *   });
+         * }
+         *
+         * @alias vision.images.annotate
+         * @memberOf! vision(v1)
+         *
+         * @param {object} params Parameters for request
+         * @param {vision(v1).BatchAnnotateImagesRequest} params.resource Request body data
+         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param {callback} callback The callback that handles the response.
+         * @return {object} Request object
+         */
+        annotate: function (params, options, callback) {
+            if (typeof options === 'function') {
+                callback = options;
+                options = {};
+            }
+            options || (options = {});
+            const rootUrl = options.rootUrl || 'https://vision.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/images:annotate').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST'
+                }, options),
+                params: params,
+                requiredParams: [],
+                pathParams: [],
+                context: self
+            };
+            return apirequest_1.default(parameters, callback);
+        }
+    };
+}
+module.exports = Vision;
+//# sourceMappingURL=v1.js.map

backend/node_modules/googleapis/apis/vision/v1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v1.js","sourceRoot":"","sources":["v1.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;AAEH,0BAA0B;AAE1B,qDAAoD;AAEpD;;;;;;;;;;;;;;GAcG;AACH,gBAAgB,OAAO;IACrB,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,IAAI,CAAC,QAAQ,GAAG,OAAO,IAAI,EAAE,CAAC;IAE9B,IAAI,CAAC,MAAM,GAAG;QAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiEG;QACH,QAAQ,EAAE,UAAU,MAAM,EAAE,OAAO,EAAE,QAAQ;YAC3C,EAAE,CAAC,CAAC,OAAO,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC;gBAClC,QAAQ,GAAG,OAAO,CAAC;gBACnB,OAAO,GAAG,EAAE,CAAC;YACf,CAAC;YACD,OAAO,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC;YAE1B,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,gCAAgC,CAAC;YAEpE,MAAM,UAAU,GAAG;gBACjB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC;oBACrB,GAAG,EAAE,CAAC,OAAO,GAAG,qBAAqB,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC;oBACpE,MAAM,EAAE,MAAM;iBACf,EAAE,OAAO,CAAC;gBACX,MAAM,EAAE,MAAM;gBACd,cAAc,EAAE,EAAE;gBAClB,UAAU,EAAE,EAAE;gBACd,OAAO,EAAE,IAAI;aACd,CAAC;YAEF,MAAM,CAAC,oBAAgB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAChD,CAAC;KAEF,CAAC;AACJ,CAAC;AA+fD,iBAAS,MAAM,CAAC"}

backend/node_modules/googleapis/apis/vision/v1.ts

@@ -0,0 +1,643 @@
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* jshint maxlen: false */
+
+import createAPIRequest from '../../lib/apirequest';
+
+/**
+ * Google Cloud Vision API
+ *
+ * Integrates Google Vision features, including image labeling, face, logo, and landmark detection, optical character recognition (OCR), and detection of explicit content, into applications.
+ *
+ * @example
+ * const google = require('googleapis');
+ * const vision = google.vision('v1');
+ *
+ * @namespace vision
+ * @type {Function}
+ * @version v1
+ * @variation v1
+ * @param {object=} options Options for Vision
+ */
+function Vision(options) { // eslint-disable-line
+  const self = this;
+  self._options = options || {};
+
+  self.images = {
+
+    /**
+     * vision.images.annotate
+     *
+     * @desc Run image detection and annotation for a batch of images.
+     *
+     * @example
+     * // BEFORE RUNNING:
+     * // ---------------
+     * // 1. If not already done, enable the Google Cloud Vision API
+     * //    and check the quota for your project at
+     * //    https://console.developers.google.com/apis/api/vision
+     * // 2. This sample uses Application Default Credentials for authentication.
+     * //    If not already done, install the gcloud CLI from
+     * //    https://cloud.google.com/sdk and run
+     * //    `gcloud beta auth application-default login`.
+     * //    For more information, see
+     * //    https://developers.google.com/identity/protocols/application-default-credentials
+     * // 3. Install the Node.js client library by running
+     * //    `npm install googleapis --save`
+     *
+     * var google = require('googleapis');
+     * var vision = google.vision('v1');
+     *
+     * authorize(function(authClient) {
+     *   var request = {
+     *     resource: {
+     *       // TODO: Add desired properties to the request body.
+     *     },
+     *
+     *     auth: authClient,
+     *   };
+     *
+     *   vision.images.annotate(request, function(err, response) {
+     *     if (err) {
+     *       console.error(err);
+     *       return;
+     *     }
+     *
+     *     // TODO: Change code below to process the `response` object:
+     *     console.log(JSON.stringify(response, null, 2));
+     *   });
+     * });
+     *
+     * function authorize(callback) {
+     *   google.auth.getApplicationDefault(function(err, authClient) {
+     *     if (err) {
+     *       console.error('authentication failed: ', err);
+     *       return;
+     *     }
+     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
+     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
+     *       authClient = authClient.createScoped(scopes);
+     *     }
+     *     callback(authClient);
+     *   });
+     * }
+     *
+     * @alias vision.images.annotate
+     * @memberOf! vision(v1)
+     *
+     * @param {object} params Parameters for request
+     * @param {vision(v1).BatchAnnotateImagesRequest} params.resource Request body data
+     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param {callback} callback The callback that handles the response.
+     * @return {object} Request object
+     */
+    annotate: function (params, options, callback) {
+      if (typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
+      options || (options = {});
+
+      const rootUrl = options.rootUrl || 'https://vision.googleapis.com/';
+
+      const parameters = {
+        options: Object.assign({
+          url: (rootUrl + '/v1/images:annotate').replace(/([^:]\/)\/+/g, '$1'),
+          method: 'POST'
+        }, options),
+        params: params,
+        requiredParams: [],
+        pathParams: [],
+        context: self
+      };
+
+      return createAPIRequest(parameters, callback);
+    }
+
+  };
+}
+
+/**
+ * @typedef AnnotateImageRequest
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).Feature[]} features Requested features.
+ * @property {vision(v1).Image} image The image to be processed.
+ * @property {vision(v1).ImageContext} imageContext Additional context that may accompany the image.
+ */
+
+/**
+ * @typedef AnnotateImageResponse
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).CropHintsAnnotation} cropHintsAnnotation If present, crop hints have completed successfully.
+* @property {vision(v1).Status} error If set, represents the error message for the operation.
+Note that filled-in image annotations are guaranteed to be
+correct, even when `error` is set.
+* @property {vision(v1).FaceAnnotation[]} faceAnnotations If present, face detection has completed successfully.
+* @property {vision(v1).TextAnnotation} fullTextAnnotation If present, text (OCR) detection or document (OCR) text detection has
+completed successfully.
+This annotation provides the structural hierarchy for the OCR detected
+text.
+* @property {vision(v1).ImageProperties} imagePropertiesAnnotation If present, image properties were extracted successfully.
+* @property {vision(v1).EntityAnnotation[]} labelAnnotations If present, label detection has completed successfully.
+* @property {vision(v1).EntityAnnotation[]} landmarkAnnotations If present, landmark detection has completed successfully.
+* @property {vision(v1).EntityAnnotation[]} logoAnnotations If present, logo detection has completed successfully.
+* @property {vision(v1).SafeSearchAnnotation} safeSearchAnnotation If present, safe-search annotation has completed successfully.
+* @property {vision(v1).EntityAnnotation[]} textAnnotations If present, text (OCR) detection has completed successfully.
+* @property {vision(v1).WebDetection} webDetection If present, web detection has completed successfully.
+*/
+
+/**
+ * @typedef BatchAnnotateImagesRequest
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).AnnotateImageRequest[]} requests Individual image annotation requests for this batch.
+ */
+
+/**
+ * @typedef BatchAnnotateImagesResponse
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).AnnotateImageResponse[]} responses Individual responses to image annotation requests within the batch.
+ */
+
+/**
+ * @typedef Block
+ * @memberOf! vision(v1)
+ * @type object
+* @property {string} blockType Detected block type (text, image etc) for this block.
+* @property {vision(v1).BoundingPoly} boundingBox The bounding box for the block.
+The vertices are in the order of top-left, top-right, bottom-right,
+bottom-left. When a rotation of the bounding box is detected the rotation
+is represented as around the top-left corner as defined when the text is
+read in the 'natural' orientation.
+For example:
+  * when the text is horizontal it might look like:
+     0----1
+     |    |
+     3----2
+  * when it's rotated 180 degrees around the top-left corner it becomes:
+     2----3
+     |    |
+     1----0
+  and the vertice order will still be (0, 1, 2, 3).
+* @property {vision(v1).Paragraph[]} paragraphs List of paragraphs in this block (if this blocks is of type text).
+* @property {vision(v1).TextProperty} property Additional information detected for the block.
+*/
+
+/**
+ * @typedef BoundingPoly
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).Vertex[]} vertices The bounding polygon vertices.
+ */
+
+/**
+ * @typedef Color
+ * @memberOf! vision(v1)
+ * @type object
+* @property {number} alpha The fraction of this color that should be applied to the pixel. That is,
+the final pixel color is defined by the equation:
+
+  pixel color = alpha * (this color) + (1.0 - alpha) * (background color)
+
+This means that a value of 1.0 corresponds to a solid color, whereas
+a value of 0.0 corresponds to a completely transparent color. This
+uses a wrapper message rather than a simple float scalar so that it is
+possible to distinguish between a default value and the value being unset.
+If omitted, this color object is to be rendered as a solid color
+(as if the alpha value had been explicitly given with a value of 1.0).
+* @property {number} blue The amount of blue in the color as a value in the interval [0, 1].
+* @property {number} green The amount of green in the color as a value in the interval [0, 1].
+* @property {number} red The amount of red in the color as a value in the interval [0, 1].
+*/
+
+/**
+ * @typedef ColorInfo
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).Color} color RGB components of the color.
+* @property {number} pixelFraction The fraction of pixels the color occupies in the image.
+Value in range [0, 1].
+* @property {number} score Image-specific score for this color. Value in range [0, 1].
+*/
+
+/**
+ * @typedef CropHint
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).BoundingPoly} boundingPoly The bounding polygon for the crop region. The coordinates of the bounding
+box are in the original image's scale, as returned in `ImageParams`.
+* @property {number} confidence Confidence of this being a salient region.  Range [0, 1].
+* @property {number} importanceFraction Fraction of importance of this salient region with respect to the original
+image.
+*/
+
+/**
+ * @typedef CropHintsAnnotation
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).CropHint[]} cropHints Crop hint results.
+ */
+
+/**
+ * @typedef CropHintsParams
+ * @memberOf! vision(v1)
+ * @type object
+* @property {number[]} aspectRatios Aspect ratios in floats, representing the ratio of the width to the height
+of the image. For example, if the desired aspect ratio is 4/3, the
+corresponding float value should be 1.33333.  If not specified, the
+best possible crop is returned. The number of provided aspect ratios is
+limited to a maximum of 16; any aspect ratios provided after the 16th are
+ignored.
+*/
+
+/**
+ * @typedef DetectedBreak
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {boolean} isPrefix True if break prepends the element.
+ * @property {string} type Detected break type.
+ */
+
+/**
+ * @typedef DetectedLanguage
+ * @memberOf! vision(v1)
+ * @type object
+* @property {number} confidence Confidence of detected language. Range [0, 1].
+* @property {string} languageCode The BCP-47 language code, such as "en-US" or "sr-Latn". For more
+information, see
+http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
+*/
+
+/**
+ * @typedef DominantColorsAnnotation
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).ColorInfo[]} colors RGB color values with their score and pixel fraction.
+ */
+
+/**
+ * @typedef EntityAnnotation
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).BoundingPoly} boundingPoly Image region to which this entity belongs. Not produced
+for `LABEL_DETECTION` features.
+* @property {number} confidence The accuracy of the entity detection in an image.
+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].
+* @property {string} description Entity textual description, expressed in its `locale` language.
+* @property {string} locale The language code for the locale in which the entity textual
+`description` is expressed.
+* @property {vision(v1).LocationInfo[]} locations The location information for the detected entity. Multiple
+`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.
+* @property {string} mid Opaque entity ID. Some IDs may be available in
+[Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).
+* @property {vision(v1).Property[]} properties Some entities may have optional user-supplied `Property` (name/value)
+fields, such a score or string that qualifies the entity.
+* @property {number} score Overall score of the result. Range [0, 1].
+* @property {number} topicality The relevancy of the ICA (Image Content Annotation) label to the
+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].
+*/
+
+/**
+ * @typedef FaceAnnotation
+ * @memberOf! vision(v1)
+ * @type object
+* @property {string} angerLikelihood Anger likelihood.
+* @property {string} blurredLikelihood Blurred likelihood.
+* @property {vision(v1).BoundingPoly} boundingPoly The bounding polygon around the face. The coordinates of the bounding box
+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.
+* @property {number} detectionConfidence Detection confidence. Range [0, 1].
+* @property {vision(v1).BoundingPoly} fdBoundingPoly 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.
+* @property {string} headwearLikelihood Headwear likelihood.
+* @property {string} joyLikelihood Joy likelihood.
+* @property {number} landmarkingConfidence Face landmarking confidence. Range [0, 1].
+* @property {vision(v1).Landmark[]} landmarks Detected face landmarks.
+* @property {number} panAngle 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].
+* @property {number} rollAngle 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].
+* @property {string} sorrowLikelihood Sorrow likelihood.
+* @property {string} surpriseLikelihood Surprise likelihood.
+* @property {number} tiltAngle Pitch angle, which indicates the upwards/downwards angle that the face is
+pointing relative to the image's horizontal plane. Range [-180,180].
+* @property {string} underExposedLikelihood Under-exposed likelihood.
+*/
+
+/**
+ * @typedef Feature
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {integer} maxResults Maximum number of results of this type.
+ * @property {string} type The feature type.
+ */
+
+/**
+ * @typedef Image
+ * @memberOf! vision(v1)
+ * @type object
+* @property {string} content Image content, represented as a stream of bytes.
+Note: as with all `bytes` fields, protobuffers use a pure binary
+representation, whereas JSON representations use base64.
+* @property {vision(v1).ImageSource} source 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.
+*/
+
+/**
+ * @typedef ImageContext
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).CropHintsParams} cropHintsParams Parameters for crop hints annotation request.
+* @property {string[]} languageHints 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](/vision/docs/languages).
+* @property {vision(v1).LatLongRect} latLongRect lat/long rectangle that specifies the location of the image.
+*/
+
+/**
+ * @typedef ImageProperties
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).DominantColorsAnnotation} dominantColors If present, dominant colors completed successfully.
+ */
+
+/**
+ * @typedef ImageSource
+ * @memberOf! vision(v1)
+ * @type object
+* @property {string} gcsImageUri NOTE: For new code `image_uri` below is preferred.
+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.
+* @property {string} imageUri Image URI which supports:
+1) 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.
+2) Publicly accessible image HTTP/HTTPS URL.
+This is preferred over the legacy `gcs_image_uri` above. When both
+`gcs_image_uri` and `image_uri` are specified, `image_uri` takes
+precedence.
+*/
+
+/**
+ * @typedef Landmark
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).Position} position Face landmark position.
+ * @property {string} type Face landmark type.
+ */
+
+/**
+ * @typedef LatLng
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {number} latitude The latitude in degrees. It must be in the range [-90.0, +90.0].
+ * @property {number} longitude The longitude in degrees. It must be in the range [-180.0, +180.0].
+ */
+
+/**
+ * @typedef LatLongRect
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).LatLng} maxLatLng Max lat/long pair.
+ * @property {vision(v1).LatLng} minLatLng Min lat/long pair.
+ */
+
+/**
+ * @typedef LocationInfo
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).LatLng} latLng lat/long location coordinates.
+ */
+
+/**
+ * @typedef Page
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).Block[]} blocks List of blocks of text, images etc on this page.
+ * @property {integer} height Page height in pixels.
+ * @property {vision(v1).TextProperty} property Additional information detected on the page.
+ * @property {integer} width Page width in pixels.
+ */
+
+/**
+ * @typedef Paragraph
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).BoundingPoly} boundingBox The bounding box for the paragraph.
+The vertices are in the order of top-left, top-right, bottom-right,
+bottom-left. When a rotation of the bounding box is detected the rotation
+is represented as around the top-left corner as defined when the text is
+read in the 'natural' orientation.
+For example:
+  * when the text is horizontal it might look like:
+     0----1
+     |    |
+     3----2
+  * when it's rotated 180 degrees around the top-left corner it becomes:
+     2----3
+     |    |
+     1----0
+  and the vertice order will still be (0, 1, 2, 3).
+* @property {vision(v1).TextProperty} property Additional information detected for the paragraph.
+* @property {vision(v1).Word[]} words List of words in this paragraph.
+*/
+
+/**
+ * @typedef Position
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {number} x X coordinate.
+ * @property {number} y Y coordinate.
+ * @property {number} z Z coordinate (or depth).
+ */
+
+/**
+ * @typedef Property
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {string} name Name of the property.
+ * @property {string} uint64Value Value of numeric properties.
+ * @property {string} value Value of the property.
+ */
+
+/**
+ * @typedef SafeSearchAnnotation
+ * @memberOf! vision(v1)
+ * @type object
+* @property {string} adult Represents the adult content likelihood for the image.
+* @property {string} medical Likelihood that this is a medical image.
+* @property {string} spoof Spoof likelihood. The likelihood that an modification
+was made to the image's canonical version to make it appear
+funny or offensive.
+* @property {string} violence Violence likelihood.
+*/
+
+/**
+ * @typedef Status
+ * @memberOf! vision(v1)
+ * @type object
+* @property {integer} code The status code, which should be an enum value of google.rpc.Code.
+* @property {object[]} details A list of messages that carry the error details.  There is a common set of
+message types for APIs to use.
+* @property {string} message A developer-facing error message, which should be in English. Any
+user-facing error message should be localized and sent in the
+google.rpc.Status.details field, or localized by the client.
+*/
+
+/**
+ * @typedef Symbol
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).BoundingPoly} boundingBox The bounding box for the symbol.
+The vertices are in the order of top-left, top-right, bottom-right,
+bottom-left. When a rotation of the bounding box is detected the rotation
+is represented as around the top-left corner as defined when the text is
+read in the 'natural' orientation.
+For example:
+  * when the text is horizontal it might look like:
+     0----1
+     |    |
+     3----2
+  * when it's rotated 180 degrees around the top-left corner it becomes:
+     2----3
+     |    |
+     1----0
+  and the vertice order will still be (0, 1, 2, 3).
+* @property {vision(v1).TextProperty} property Additional information detected for the symbol.
+* @property {string} text The actual UTF-8 representation of the symbol.
+*/
+
+/**
+ * @typedef TextAnnotation
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).Page[]} pages List of pages detected by OCR.
+ * @property {string} text UTF-8 text detected on the pages.
+ */
+
+/**
+ * @typedef TextProperty
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {vision(v1).DetectedBreak} detectedBreak Detected start or end of a text segment.
+ * @property {vision(v1).DetectedLanguage[]} detectedLanguages A list of detected languages together with confidence.
+ */
+
+/**
+ * @typedef Vertex
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {integer} x X coordinate.
+ * @property {integer} y Y coordinate.
+ */
+
+/**
+ * @typedef WebDetection
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).WebImage[]} fullMatchingImages Fully matching images from the Internet.
+Can include resized copies of the query image.
+* @property {vision(v1).WebPage[]} pagesWithMatchingImages Web pages containing the matching images from the Internet.
+* @property {vision(v1).WebImage[]} partialMatchingImages Partial matching images from the Internet.
+Those images are similar enough to share some key-point features. For
+example an original image will likely have partial matching for its crops.
+* @property {vision(v1).WebImage[]} visuallySimilarImages The visually similar image results.
+* @property {vision(v1).WebEntity[]} webEntities Deduced entities from similar images on the Internet.
+*/
+
+/**
+ * @typedef WebEntity
+ * @memberOf! vision(v1)
+ * @type object
+* @property {string} description Canonical description of the entity, in English.
+* @property {string} entityId Opaque entity ID.
+* @property {number} score Overall relevancy score for the entity.
+Not normalized and not comparable across different image queries.
+*/
+
+/**
+ * @typedef WebImage
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {number} score (Deprecated) Overall relevancy score for the image.
+ * @property {string} url The result image URL.
+ */
+
+/**
+ * @typedef WebPage
+ * @memberOf! vision(v1)
+ * @type object
+ * @property {number} score (Deprecated) Overall relevancy score for the web page.
+ * @property {string} url The result web page URL.
+ */
+
+/**
+ * @typedef Word
+ * @memberOf! vision(v1)
+ * @type object
+* @property {vision(v1).BoundingPoly} boundingBox The bounding box for the word.
+The vertices are in the order of top-left, top-right, bottom-right,
+bottom-left. When a rotation of the bounding box is detected the rotation
+is represented as around the top-left corner as defined when the text is
+read in the 'natural' orientation.
+For example:
+  * when the text is horizontal it might look like:
+     0----1
+     |    |
+     3----2
+  * when it's rotated 180 degrees around the top-left corner it becomes:
+     2----3
+     |    |
+     1----0
+  and the vertice order will still be (0, 1, 2, 3).
+* @property {vision(v1).TextProperty} property Additional information detected for the word.
+* @property {vision(v1).Symbol[]} symbols List of symbols in the word.
+The order of the symbols follows the natural reading order.
+*/
+export = Vision;