Api-Roll 52: 2017-07-31

generated/googleapis/lib/streetviewpublish/v1.dart

Index: generated/googleapis/lib/streetviewpublish/v1.dart
diff --git a/generated/googleapis/lib/streetviewpublish/v1.dart b/generated/googleapis/lib/streetviewpublish/v1.dart
new file mode 100644
index 0000000000000000000000000000000000000000..ea6b58e37315ebc73cdd98dcdf61f895270c8441
--- /dev/null
+++ b/generated/googleapis/lib/streetviewpublish/v1.dart
@@ -0,0 +1,1409 @@
+// This is a generated file (see the discoveryapis_generator project).
+
+library googleapis.streetviewpublish.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;
+
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError;
+
+const core.String USER_AGENT = 'dart-api-client streetviewpublish/v1';
+
+/**
+ * Publishes 360 photos to Google Maps, along with position, orientation, and
+ * connectivity metadata. Apps can offer an interface for positioning,
+ * connecting, and uploading user-generated Street View images.
+ */
+class StreetviewpublishApi {
+  /** Publish and manage your 360 photos on Google Street View */
+  static const StreetviewpublishScope = "https://www.googleapis.com/auth/streetviewpublish";
+
+
+  final commons.ApiRequester _requester;
+
+  PhotoResourceApi get photo => new PhotoResourceApi(_requester);
+  PhotosResourceApi get photos => new PhotosResourceApi(_requester);
+
+  StreetviewpublishApi(http.Client client, {core.String rootUrl: "https://streetviewpublish.googleapis.com/", core.String servicePath: ""}) :
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
+}
+
+
+class PhotoResourceApi {
+  final commons.ApiRequester _requester;
+
+  PhotoResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * After the client finishes uploading the photo with the returned
+   * UploadRef,
+   * CreatePhoto
+   * publishes the uploaded Photo to
+   * Street View on Google Maps.
+   *
+   * This method returns the following error codes:
+   *
+   * * google.rpc.Code.INVALID_ARGUMENT if the request is malformed.
+   * * google.rpc.Code.NOT_FOUND if the upload reference does not exist.
+   * * google.rpc.Code.RESOURCE_EXHAUSTED if the account has reached the
+   * storage limit.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * Completes with a [Photo].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<Photo> create(Photo request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+    _url = 'v1/photo';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Photo.fromJson(data));
+  }
+
+  /**
+   * Deletes a Photo and its metadata.
+   *
+   * This method returns the following error codes:
+   *
+   * * google.rpc.Code.PERMISSION_DENIED if the requesting user did not
+   * create the requested photo.
+   * * google.rpc.Code.NOT_FOUND if the photo ID does not exist.
+   *
+   * Request parameters:
+   *
+   * [photoId] - Required. ID of the Photo.
+   *
+   * Completes with a [Empty].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<Empty> delete(core.String photoId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (photoId == null) {
+      throw new core.ArgumentError("Parameter photoId is required.");
+    }
+
+    _url = 'v1/photo/' + commons.Escaper.ecapeVariable('$photoId');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Empty.fromJson(data));
+  }
+
+  /**
+   * Gets the metadata of the specified
+   * Photo.
+   *
+   * This method returns the following error codes:
+   *
+   * * google.rpc.Code.PERMISSION_DENIED if the requesting user did not
+   * create the requested Photo.
+   * * google.rpc.Code.NOT_FOUND if the requested
+   * Photo does not exist.
+   *
+   * Request parameters:
+   *
+   * [photoId] - Required. ID of the Photo.
+   *
+   * [view] - Specifies if a download URL for the photo bytes should be returned
+   * in the
+   * Photo response.
+   * Possible string values are:
+   * - "BASIC" : A BASIC.
+   * - "INCLUDE_DOWNLOAD_URL" : A INCLUDE_DOWNLOAD_URL.
+   *
+   * Completes with a [Photo].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<Photo> get(core.String photoId, {core.String view}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (photoId == null) {
+      throw new core.ArgumentError("Parameter photoId is required.");
+    }
+    if (view != null) {
+      _queryParams["view"] = [view];
+    }
+
+    _url = 'v1/photo/' + commons.Escaper.ecapeVariable('$photoId');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Photo.fromJson(data));
+  }
+
+  /**
+   * Creates an upload session to start uploading photo bytes. The upload URL of
+   * the returned UploadRef is used to
+   * upload the bytes for the Photo.
+   *
+   * In addition to the photo requirements shown in
+   * https://support.google.com/maps/answer/7012050?hl=en&ref_topic=6275604,
+   * the photo must also meet the following requirements:
+   *
+   * * Photo Sphere XMP metadata must be included in the photo medadata. See
+   * https://developers.google.com/streetview/spherical-metadata for the
+   * required fields.
+   * * The pixel size of the photo must meet the size requirements listed in
+   * https://support.google.com/maps/answer/7012050?hl=en&ref_topic=6275604, and
+   * the photo must be a full 360 horizontally.
+   *
+   * After the upload is complete, the
+   * UploadRef is used with
+   * CreatePhoto
+   * to create the Photo object entry.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * Completes with a [UploadRef].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<UploadRef> startUpload(Empty request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+    _url = 'v1/photo:startUpload';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new UploadRef.fromJson(data));
+  }
+
+  /**
+   * Updates the metadata of a Photo, such
+   * as pose, place association, connections, etc. Changing the pixels of a
+   * photo is not supported.
+   *
+   * This method returns the following error codes:
+   *
+   * * google.rpc.Code.PERMISSION_DENIED if the requesting user did not
+   * create the requested photo.
+   * * google.rpc.Code.INVALID_ARGUMENT if the request is malformed.
+   * * google.rpc.Code.NOT_FOUND if the requested photo does not exist.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [id] - Required. A base64 encoded identifier.
+   *
+   * [updateMask] - Mask that identifies fields on the photo metadata to update.
+   * If not present, the old Photo metadata will be entirely replaced with the
+   * new Photo metadata in this request. The update fails if invalid fields are
+   * specified. Multiple fields can be specified in a comma-delimited list.
+   *
+   * The following fields are valid:
+   *
+   * * `pose.heading`
+   * * `pose.latlngpair`
+   * * `pose.pitch`
+   * * `pose.roll`
+   * * `pose.level`
+   * * `pose.altitude`
+   * * `connections`
+   * * `places`
+   *
+   *
+   * <aside class="note"><b>Note:</b> Repeated fields in
+   * updateMask
+   * mean the entire set of repeated values will be replaced with the new
+   * contents. For example, if
+   * updateMask
+   * contains `connections` and
+   * google.streetview.publish.v1.UpdatePhotoRequest.photo.connections is
+   * empty, all connections will be removed.</aside>
+   *
+   * Completes with a [Photo].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<Photo> update(Photo request, core.String id, {core.String updateMask}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (id == null) {
+      throw new core.ArgumentError("Parameter id is required.");
+    }
+    if (updateMask != null) {
+      _queryParams["updateMask"] = [updateMask];
+    }
+
+    _url = 'v1/photo/' + commons.Escaper.ecapeVariable('$id');
+
+    var _response = _requester.request(_url,
+                                       "PUT",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Photo.fromJson(data));
+  }
+
+}
+
+
+class PhotosResourceApi {
+  final commons.ApiRequester _requester;
+
+  PhotosResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Deletes a list of Photos and their metadata.
+   *
+   * Note that if
+   * BatchDeletePhotos
+   * fails, either critical fields are missing or there was an authentication
+   * error. Even if
+   * BatchDeletePhotos
+   * succeeds, there may have been failures for single photos in the batch.
+   * These failures will be specified in each
+   * PhotoResponse.status
+   * in
+   * BatchDeletePhotosResponse.results.
+   * See
+   * DeletePhoto
+   * for specific failures that can occur per photo.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * Completes with a [BatchDeletePhotosResponse].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<BatchDeletePhotosResponse> batchDelete(BatchDeletePhotosRequest request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+    _url = 'v1/photos:batchDelete';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new BatchDeletePhotosResponse.fromJson(data));
+  }
+
+  /**
+   * Gets the metadata of the specified
+   * Photo batch.
+   *
+   * Note that if
+   * BatchGetPhotos
+   * fails, either critical fields are missing or there was an authentication
+   * error. Even if
+   * BatchGetPhotos
+   * succeeds, there may have been failures for single photos in the batch.
+   * These failures will be specified in each
+   * PhotoResponse.status
+   * in
+   * BatchGetPhotosResponse.results.
+   * See
+   * GetPhoto
+   * for specific failures that can occur per photo.
+   *
+   * Request parameters:
+   *
+   * [view] - Specifies if a download URL for the photo bytes should be returned
+   * in the
+   * Photo response.
+   * Possible string values are:
+   * - "BASIC" : A BASIC.
+   * - "INCLUDE_DOWNLOAD_URL" : A INCLUDE_DOWNLOAD_URL.
+   *
+   * [photoIds] - Required. IDs of the Photos. For HTTP
+   * GET requests, the URL query parameter should be
+   * `photoIds=<id1>&photoIds=<id2>&...`.
+   *
+   * Completes with a [BatchGetPhotosResponse].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<BatchGetPhotosResponse> batchGet({core.String view, core.List<core.String> photoIds}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (view != null) {
+      _queryParams["view"] = [view];
+    }
+    if (photoIds != null) {
+      _queryParams["photoIds"] = photoIds;
+    }
+
+    _url = 'v1/photos:batchGet';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new BatchGetPhotosResponse.fromJson(data));
+  }
+
+  /**
+   * Updates the metadata of Photos, such
+   * as pose, place association, connections, etc. Changing the pixels of photos
+   * is not supported.
+   *
+   * Note that if
+   * BatchUpdatePhotos
+   * fails, either critical fields are missing or there was an authentication
+   * error. Even if
+   * BatchUpdatePhotos
+   * succeeds, there may have been failures for single photos in the batch.
+   * These failures will be specified in each
+   * PhotoResponse.status
+   * in
+   * BatchUpdatePhotosResponse.results.
+   * See
+   * UpdatePhoto
+   * for specific failures that can occur per photo.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * Completes with a [BatchUpdatePhotosResponse].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<BatchUpdatePhotosResponse> batchUpdate(BatchUpdatePhotosRequest request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+    _url = 'v1/photos:batchUpdate';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new BatchUpdatePhotosResponse.fromJson(data));
+  }
+
+  /**
+   * Lists all the Photos that belong to the user.
+   *
+   * Request parameters:
+   *
+   * [pageToken] - The
+   * nextPageToken
+   * value returned from a previous
+   * ListPhotos
+   * request, if any.
+   *
+   * [pageSize] - The maximum number of photos to return.
+   * `pageSize` must be non-negative. If `pageSize` is zero or is not provided,
+   * the default page size of 100 will be used.
+   * The number of photos returned in the response may be less than `pageSize`
+   * if the number of photos that belong to the user is less than `pageSize`.
+   *
+   * [view] - Specifies if a download URL for the photos bytes should be
+   * returned in the
+   * Photos response.
+   * Possible string values are:
+   * - "BASIC" : A BASIC.
+   * - "INCLUDE_DOWNLOAD_URL" : A INCLUDE_DOWNLOAD_URL.
+   *
+   * [filter] - The filter expression. For example:
+   * `placeId=ChIJj61dQgK6j4AR4GeTYWZsKWw`.
+   *
+   * Completes with a [ListPhotosResponse].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<ListPhotosResponse> list({core.String pageToken, core.int pageSize, core.String view, core.String filter}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (view != null) {
+      _queryParams["view"] = [view];
+    }
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
+    }
+
+    _url = 'v1/photos';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new ListPhotosResponse.fromJson(data));
+  }
+
+}
+
+
+
+/** Request to delete multiple Photos. */
+class BatchDeletePhotosRequest {
+  /**
+   * Required. IDs of the Photos. For HTTP
+   * GET requests, the URL query parameter should be
+   * `photoIds=<id1>&photoIds=<id2>&...`.
+   */
+  core.List<core.String> photoIds;
+
+  BatchDeletePhotosRequest();
+
+  BatchDeletePhotosRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("photoIds")) {
+      photoIds = _json["photoIds"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (photoIds != null) {
+      _json["photoIds"] = photoIds;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Response to batch delete of one or more
+ * Photos.
+ */
+class BatchDeletePhotosResponse {
+  /**
+   * The status for the operation to delete a single
+   * Photo in the batch request.
+   */
+  core.List<Status> status;
+
+  BatchDeletePhotosResponse();
+
+  BatchDeletePhotosResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("status")) {
+      status = _json["status"].map((value) => new Status.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (status != null) {
+      _json["status"] = status.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/** Response to batch get of Photos. */
+class BatchGetPhotosResponse {
+  /**
+   * List of results for each individual
+   * Photo requested, in the same order as
+   * the requests in
+   * BatchGetPhotos.
+   */
+  core.List<PhotoResponse> results;
+
+  BatchGetPhotosResponse();
+
+  BatchGetPhotosResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("results")) {
+      results = _json["results"].map((value) => new PhotoResponse.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (results != null) {
+      _json["results"] = results.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/**
+ * Request to update the metadata of photos.
+ * Updating the pixels of photos is not supported.
+ */
+class BatchUpdatePhotosRequest {
+  /**
+   * Required. List of
+   * UpdatePhotoRequests.
+   */
+  core.List<UpdatePhotoRequest> updatePhotoRequests;
+
+  BatchUpdatePhotosRequest();
+
+  BatchUpdatePhotosRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("updatePhotoRequests")) {
+      updatePhotoRequests = _json["updatePhotoRequests"].map((value) => new UpdatePhotoRequest.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (updatePhotoRequests != null) {
+      _json["updatePhotoRequests"] = updatePhotoRequests.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/**
+ * Response to batch update of metadata of one or more
+ * Photos.
+ */
+class BatchUpdatePhotosResponse {
+  /**
+   * List of results for each individual
+   * Photo updated, in the same order as
+   * the request.
+   */
+  core.List<PhotoResponse> results;
+
+  BatchUpdatePhotosResponse();
+
+  BatchUpdatePhotosResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("results")) {
+      results = _json["results"].map((value) => new PhotoResponse.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (results != null) {
+      _json["results"] = results.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/** A connection is the link from a source photo to a destination photo. */
+class Connection {
+  /**
+   * Required. The destination of the connection from the containing photo to
+   * another photo.
+   */
+  PhotoId target;
+
+  Connection();
+
+  Connection.fromJson(core.Map _json) {
+    if (_json.containsKey("target")) {
+      target = new PhotoId.fromJson(_json["target"]);
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (target != null) {
+      _json["target"] = (target).toJson();
+    }
+    return _json;
+  }
+}
+
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ *
+ * The JSON representation for `Empty` is empty JSON object `{}`.
+ */
+class Empty {
+
+  Empty();
+
+  Empty.fromJson(core.Map _json) {
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    return _json;
+  }
+}
+
+/**
+ * An object representing a latitude/longitude pair. This is expressed as a pair
+ * of doubles representing degrees latitude and degrees longitude. Unless
+ * specified otherwise, this must conform to the
+ * <a href="http://www.unoosa.org/pdf/icg/2012/template/WGS_84.pdf">WGS84
+ * standard</a>. Values must be within normalized ranges.
+ *
+ * Example of normalization code in Python:
+ *
+ *     def NormalizeLongitude(longitude):
+ *       """Wraps decimal degrees longitude to [-180.0, 180.0]."""
+ *       q, r = divmod(longitude, 360.0)
+ *       if r > 180.0 or (r == 180.0 and q <= -1.0):
+ *         return r - 360.0
+ *       return r
+ *
+ *     def NormalizeLatLng(latitude, longitude):
+ *       """Wraps decimal degrees latitude and longitude to
+ *       [-90.0, 90.0] and [-180.0, 180.0], respectively."""
+ *       r = latitude % 360.0
+ *       if r <= 90.0:
+ *         return r, NormalizeLongitude(longitude)
+ *       elif r >= 270.0:
+ *         return r - 360, NormalizeLongitude(longitude)
+ *       else:
+ *         return 180 - r, NormalizeLongitude(longitude + 180.0)
+ *
+ *     assert 180.0 == NormalizeLongitude(180.0)
+ *     assert -180.0 == NormalizeLongitude(-180.0)
+ *     assert -179.0 == NormalizeLongitude(181.0)
+ *     assert (0.0, 0.0) == NormalizeLatLng(360.0, 0.0)
+ *     assert (0.0, 0.0) == NormalizeLatLng(-360.0, 0.0)
+ *     assert (85.0, 180.0) == NormalizeLatLng(95.0, 0.0)
+ *     assert (-85.0, -170.0) == NormalizeLatLng(-95.0, 10.0)
+ *     assert (90.0, 10.0) == NormalizeLatLng(90.0, 10.0)
+ *     assert (-90.0, -10.0) == NormalizeLatLng(-90.0, -10.0)
+ *     assert (0.0, -170.0) == NormalizeLatLng(-180.0, 10.0)
+ *     assert (0.0, -170.0) == NormalizeLatLng(180.0, 10.0)
+ *     assert (-90.0, 10.0) == NormalizeLatLng(270.0, 10.0)
+ *     assert (90.0, 10.0) == NormalizeLatLng(-270.0, 10.0)
+ */
+class LatLng {
+  /** The latitude in degrees. It must be in the range [-90.0, +90.0]. */
+  core.double latitude;
+  /** The longitude in degrees. It must be in the range [-180.0, +180.0]. */
+  core.double longitude;
+
+  LatLng();
+
+  LatLng.fromJson(core.Map _json) {
+    if (_json.containsKey("latitude")) {
+      latitude = _json["latitude"];
+    }
+    if (_json.containsKey("longitude")) {
+      longitude = _json["longitude"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (latitude != null) {
+      _json["latitude"] = latitude;
+    }
+    if (longitude != null) {
+      _json["longitude"] = longitude;
+    }
+    return _json;
+  }
+}
+
+/** Level information containing level number and its corresponding name. */
+class Level {
+  /**
+   * Required. A name assigned to this Level, restricted to 3 characters.
+   * Consider how the elevator buttons would be labeled for this level if there
+   * was an elevator.
+   */
+  core.String name;
+  /**
+   * Floor number, used for ordering. 0 indicates the ground level, 1 indicates
+   * the first level above ground level, -1 indicates the first level under
+   * ground level. Non-integer values are OK.
+   */
+  core.double number;
+
+  Level();
+
+  Level.fromJson(core.Map _json) {
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("number")) {
+      number = _json["number"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (number != null) {
+      _json["number"] = number;
+    }
+    return _json;
+  }
+}
+
+/** Response to list all photos that belong to a user. */
+class ListPhotosResponse {
+  /**
+   * Token to retrieve the next page of results, or empty if there are no more
+   * results in the list.
+   */
+  core.String nextPageToken;
+  /**
+   * List of photos. The maximum number of items returned is based on the
+   * pageSize field
+   * in the request.
+   */
+  core.List<Photo> photos;
+
+  ListPhotosResponse();
+
+  ListPhotosResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("nextPageToken")) {
+      nextPageToken = _json["nextPageToken"];
+    }
+    if (_json.containsKey("photos")) {
+      photos = _json["photos"].map((value) => new Photo.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (nextPageToken != null) {
+      _json["nextPageToken"] = nextPageToken;
+    }
+    if (photos != null) {
+      _json["photos"] = photos.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/** Photo is used to store 360 photos along with photo metadata. */
+class Photo {
+  /**
+   * Absolute time when the photo was captured.
+   * When the photo has no exif timestamp, this is used to set a timestamp in
+   * the photo metadata.
+   */
+  core.String captureTime;
+  /**
+   * Connections to other photos. A connection represents the link from this
+   * photo to another photo.
+   */
+  core.List<Connection> connections;
+  /**
+   * Output only. The download URL for the photo bytes. This field is set only
+   * when
+   * GetPhotoRequest.view
+   * is set to
+   * PhotoView.INCLUDE_DOWNLOAD_URL.
+   */
+  core.String downloadUrl;
+  /**
+   * Required when updating photo. Output only when creating photo.
+   * Identifier for the photo, which is unique among all photos in
+   * Google.
+   */
+  PhotoId photoId;
+  /** Places where this photo belongs. */
+  core.List<Place> places;
+  /** Pose of the photo. */
+  Pose pose;
+  /** Output only. The share link for the photo. */
+  core.String shareLink;
+  /**
+   * Output only. The thumbnail URL for showing a preview of the given photo.
+   */
+  core.String thumbnailUrl;
+  /**
+   * Required when creating photo. Input only. The resource URL where the photo
+   * bytes are uploaded to.
+   */
+  UploadRef uploadReference;
+  /** Output only. View count of the photo. */
+  core.String viewCount;
+
+  Photo();
+
+  Photo.fromJson(core.Map _json) {
+    if (_json.containsKey("captureTime")) {
+      captureTime = _json["captureTime"];
+    }
+    if (_json.containsKey("connections")) {
+      connections = _json["connections"].map((value) => new Connection.fromJson(value)).toList();
+    }
+    if (_json.containsKey("downloadUrl")) {
+      downloadUrl = _json["downloadUrl"];
+    }
+    if (_json.containsKey("photoId")) {
+      photoId = new PhotoId.fromJson(_json["photoId"]);
+    }
+    if (_json.containsKey("places")) {
+      places = _json["places"].map((value) => new Place.fromJson(value)).toList();
+    }
+    if (_json.containsKey("pose")) {
+      pose = new Pose.fromJson(_json["pose"]);
+    }
+    if (_json.containsKey("shareLink")) {
+      shareLink = _json["shareLink"];
+    }
+    if (_json.containsKey("thumbnailUrl")) {
+      thumbnailUrl = _json["thumbnailUrl"];
+    }
+    if (_json.containsKey("uploadReference")) {
+      uploadReference = new UploadRef.fromJson(_json["uploadReference"]);
+    }
+    if (_json.containsKey("viewCount")) {
+      viewCount = _json["viewCount"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (captureTime != null) {
+      _json["captureTime"] = captureTime;
+    }
+    if (connections != null) {
+      _json["connections"] = connections.map((value) => (value).toJson()).toList();
+    }
+    if (downloadUrl != null) {
+      _json["downloadUrl"] = downloadUrl;
+    }
+    if (photoId != null) {
+      _json["photoId"] = (photoId).toJson();
+    }
+    if (places != null) {
+      _json["places"] = places.map((value) => (value).toJson()).toList();
+    }
+    if (pose != null) {
+      _json["pose"] = (pose).toJson();
+    }
+    if (shareLink != null) {
+      _json["shareLink"] = shareLink;
+    }
+    if (thumbnailUrl != null) {
+      _json["thumbnailUrl"] = thumbnailUrl;
+    }
+    if (uploadReference != null) {
+      _json["uploadReference"] = (uploadReference).toJson();
+    }
+    if (viewCount != null) {
+      _json["viewCount"] = viewCount;
+    }
+    return _json;
+  }
+}
+
+/** Identifier for a Photo. */
+class PhotoId {
+  /** Required. A base64 encoded identifier. */
+  core.String id;
+
+  PhotoId();
+
+  PhotoId.fromJson(core.Map _json) {
+    if (_json.containsKey("id")) {
+      id = _json["id"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (id != null) {
+      _json["id"] = id;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Response payload for a single
+ * Photo
+ * in batch operations including
+ * BatchGetPhotos
+ * and
+ * BatchUpdatePhotos.
+ */
+class PhotoResponse {
+  /**
+   * The Photo resource, if the request
+   * was successful.
+   */
+  Photo photo;
+  /**
+   * The status for the operation to get or update a single photo in the batch
+   * request.
+   */
+  Status status;
+
+  PhotoResponse();
+
+  PhotoResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("photo")) {
+      photo = new Photo.fromJson(_json["photo"]);
+    }
+    if (_json.containsKey("status")) {
+      status = new Status.fromJson(_json["status"]);
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (photo != null) {
+      _json["photo"] = (photo).toJson();
+    }
+    if (status != null) {
+      _json["status"] = (status).toJson();
+    }
+    return _json;
+  }
+}
+
+/** Place metadata for an entity. */
+class Place {
+  /**
+   * Required. Place identifier, as described in
+   * https://developers.google.com/places/place-id.
+   */
+  core.String placeId;
+
+  Place();
+
+  Place.fromJson(core.Map _json) {
+    if (_json.containsKey("placeId")) {
+      placeId = _json["placeId"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (placeId != null) {
+      _json["placeId"] = placeId;
+    }
+    return _json;
+  }
+}
+
+/** Raw pose measurement for an entity. */
+class Pose {
+  /**
+   * Altitude of the pose in meters above ground level (as defined by WGS84).
+   * NaN indicates an unmeasured quantity.
+   */
+  core.double altitude;
+  /**
+   * Compass heading, measured at the center of the photo in degrees clockwise
+   * from North. Value must be >=0 and <360.
+   * NaN indicates an unmeasured quantity.
+   */
+  core.double heading;
+  /**
+   * Latitude and longitude pair of the pose, as explained here:
+   * https://cloud.google.com/datastore/docs/reference/rest/Shared.Types/LatLng
+   * When creating a Photo, if the
+   * latitude and longitude pair are not provided here, the geolocation from the
+   * exif header will be used. If the latitude and longitude pair is not
+   * provided and cannot be found in the exif header, the create photo process
+   * will fail.
+   */
+  LatLng latLngPair;
+  /** Level (the floor in a building) used to configure vertical navigation. */
+  Level level;
+  /**
+   * Pitch, measured at the center of the photo in degrees. Value must be >=-90
+   * and <= 90. A value of -90 means looking directly down, and a value of 90
+   * means looking directly up.
+   * NaN indicates an unmeasured quantity.
+   */
+  core.double pitch;
+  /**
+   * Roll, measured in degrees. Value must be >= 0 and <360. A value of 0
+   * means level with the horizon.
+   * NaN indicates an unmeasured quantity.
+   */
+  core.double roll;
+
+  Pose();
+
+  Pose.fromJson(core.Map _json) {
+    if (_json.containsKey("altitude")) {
+      altitude = _json["altitude"];
+    }
+    if (_json.containsKey("heading")) {
+      heading = _json["heading"];
+    }
+    if (_json.containsKey("latLngPair")) {
+      latLngPair = new LatLng.fromJson(_json["latLngPair"]);
+    }
+    if (_json.containsKey("level")) {
+      level = new Level.fromJson(_json["level"]);
+    }
+    if (_json.containsKey("pitch")) {
+      pitch = _json["pitch"];
+    }
+    if (_json.containsKey("roll")) {
+      roll = _json["roll"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (altitude != null) {
+      _json["altitude"] = altitude;
+    }
+    if (heading != null) {
+      _json["heading"] = heading;
+    }
+    if (latLngPair != null) {
+      _json["latLngPair"] = (latLngPair).toJson();
+    }
+    if (level != null) {
+      _json["level"] = (level).toJson();
+    }
+    if (pitch != null) {
+      _json["pitch"] = pitch;
+    }
+    if (roll != null) {
+      _json["roll"] = roll;
+    }
+    return _json;
+  }
+}
+
+/**
+ * The `Status` type defines a logical error model that is suitable for
+ * different
+ * programming environments, including REST APIs and RPC APIs. It is used by
+ * [gRPC](https://github.com/grpc). The error model is designed to be:
+ *
+ * - Simple to use and understand for most users
+ * - Flexible enough to meet unexpected needs
+ *
+ * # Overview
+ *
+ * The `Status` message contains three pieces of data: error code, error
+ * message,
+ * and error details. The error code should be an enum value of
+ * google.rpc.Code, but it may accept additional error codes if needed.  The
+ * error message should be a developer-facing English message that helps
+ * developers *understand* and *resolve* the error. If a localized user-facing
+ * error message is needed, put the localized message in the error details or
+ * localize it in the client. The optional error details may contain arbitrary
+ * information about the error. There is a predefined set of error detail types
+ * in the package `google.rpc` that can be used for common error conditions.
+ *
+ * # Language mapping
+ *
+ * The `Status` message is the logical representation of the error model, but it
+ * is not necessarily the actual wire format. When the `Status` message is
+ * exposed in different client libraries and different wire protocols, it can be
+ * mapped differently. For example, it will likely be mapped to some exceptions
+ * in Java, but more likely mapped to some error codes in C.
+ *
+ * # Other uses
+ *
+ * The error model and the `Status` message can be used in a variety of
+ * environments, either with or without APIs, to provide a
+ * consistent developer experience across different environments.
+ *
+ * Example uses of this error model include:
+ *
+ * - Partial errors. If a service needs to return partial errors to the client,
+ *     it may embed the `Status` in the normal response to indicate the partial
+ *     errors.
+ *
+ * - Workflow errors. A typical workflow has multiple steps. Each step may
+ *     have a `Status` message for error reporting.
+ *
+ * - Batch operations. If a client uses batch request and batch response, the
+ *     `Status` message should be used directly inside batch response, one for
+ *     each error sub-response.
+ *
+ * - Asynchronous operations. If an API call embeds asynchronous operation
+ *     results in its response, the status of those operations should be
+ *     represented directly using the `Status` message.
+ *
+ * - Logging. If some API errors are stored in logs, the message `Status` could
+ * be used directly after any stripping needed for security/privacy reasons.
+ */
+class Status {
+  /** The status code, which should be an enum value of google.rpc.Code. */
+  core.int code;
+  /**
+   * A list of messages that carry the error details.  There is a common set of
+   * message types for APIs to use.
+   *
+   * The values for Object must be JSON objects. It can consist of `num`,
+   * `String`, `bool` and `null` as well as `Map` and `List` values.
+   */
+  core.List<core.Map<core.String, core.Object>> details;
+  /**
+   * 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.
+   */
+  core.String message;
+
+  Status();
+
+  Status.fromJson(core.Map _json) {
+    if (_json.containsKey("code")) {
+      code = _json["code"];
+    }
+    if (_json.containsKey("details")) {
+      details = _json["details"];
+    }
+    if (_json.containsKey("message")) {
+      message = _json["message"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (code != null) {
+      _json["code"] = code;
+    }
+    if (details != null) {
+      _json["details"] = details;
+    }
+    if (message != null) {
+      _json["message"] = message;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Request to update the metadata of a
+ * Photo. Updating the pixels of a photo
+ * is not supported.
+ */
+class UpdatePhotoRequest {
+  /**
+   * Required. Photo object containing the
+   * new metadata. Only the fields specified in
+   * updateMask
+   * field are used. If `updateMask` is not present, the update applies to all
+   * fields. <aside class="note"><b>Note:</b> To update
+   * Pose.altitude,
+   * Pose.latLngPair has to be
+   * filled as well. Otherwise, the request will fail.
+   */
+  Photo photo;
+  /**
+   * Mask that identifies fields on the photo metadata to update.
+   * If not present, the old Photo metadata will be entirely replaced with the
+   * new Photo metadata in this request. The update fails if invalid fields are
+   * specified. Multiple fields can be specified in a comma-delimited list.
+   *
+   * The following fields are valid:
+   *
+   * * `pose.heading`
+   * * `pose.latlngpair`
+   * * `pose.pitch`
+   * * `pose.roll`
+   * * `pose.level`
+   * * `pose.altitude`
+   * * `connections`
+   * * `places`
+   *
+   *
+   * <aside class="note"><b>Note:</b> Repeated fields in
+   * updateMask
+   * mean the entire set of repeated values will be replaced with the new
+   * contents. For example, if
+   * updateMask
+   * contains `connections` and
+   * google.streetview.publish.v1.UpdatePhotoRequest.photo.connections is
+   * empty, all connections will be removed.</aside>
+   */
+  core.String updateMask;
+
+  UpdatePhotoRequest();
+
+  UpdatePhotoRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("photo")) {
+      photo = new Photo.fromJson(_json["photo"]);
+    }
+    if (_json.containsKey("updateMask")) {
+      updateMask = _json["updateMask"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (photo != null) {
+      _json["photo"] = (photo).toJson();
+    }
+    if (updateMask != null) {
+      _json["updateMask"] = updateMask;
+    }
+    return _json;
+  }
+}
+
+/** Upload reference for media files. */
+class UploadRef {
+  /**
+   * Required. An upload reference should be unique for each user. It follows
+   * the form:
+   * "https://streetviewpublish.googleapis.com/media/user/{account_id}/photo/{upload_reference}"
+   */
+  core.String uploadUrl;
+
+  UploadRef();
+
+  UploadRef.fromJson(core.Map _json) {
+    if (_json.containsKey("uploadUrl")) {
+      uploadUrl = _json["uploadUrl"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (uploadUrl != null) {
+      _json["uploadUrl"] = uploadUrl;
+    }
+    return _json;
+  }
+}