// 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.
  ///
  /// Currently, the only way to set heading, pitch, and roll in CreatePhoto is
  /// through the [Photo Sphere XMP
  /// metadata](https://developers.google.com/streetview/spherical-metadata) in
  /// the photo bytes. The `pose.heading`, `pose.pitch`, `pose.roll`,
  /// `pose.altitude`, and `pose.level` fields in Pose are ignored for
  /// CreatePhoto.
  ///
  /// This method returns the following error codes:
  ///
  /// * google.rpc.Code.INVALID_ARGUMENT if the request is malformed or if
  /// the uploaded photo is not a 360 photo.
  /// * 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:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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, {core.String $fields}) {
    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 ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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, {core.String $fields}) {
    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 ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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.
  /// * google.rpc.Code.UNAVAILABLE if the requested
  /// Photo is still being indexed.
  ///
  /// 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.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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, core.String $fields}) {
    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];
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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, {core.String $fields}) {
    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 ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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.
  ///
  /// Only the fields specified in the
  /// 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.</aside>
  ///
  /// 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.
  /// * google.rpc.Code.UNAVAILABLE if the requested
  /// Photo is still being indexed.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [id] - Required. A unique identifier for a photo.
  ///
  /// [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 `UpdatePhotoRequest.photo.connections` is
  /// empty,
  /// all connections will be removed.</aside>
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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, core.String $fields}) {
    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];
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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,
      {core.String $fields}) {
    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 ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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:
  ///
  /// [photoIds] - Required. IDs of the Photos. For HTTP
  /// GET requests, the URL query parameter should be
  /// `photoIds=<id1>&photoIds=<id2>&...`.
  ///
  /// [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.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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.List<core.String> photoIds,
      core.String view,
      core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (photoIds != null) {
      _queryParams["photoIds"] = photoIds;
    }
    if (view != null) {
      _queryParams["view"] = [view];
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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.
  ///
  /// 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.</aside>
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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,
      {core.String $fields}) {
    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 ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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.
  ///
  /// <aside class="note"><b>Note:</b> Recently created photos that are still
  /// being indexed are not returned in the response.</aside>
  ///
  /// 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`.
  ///
  /// The only filter supported at the moment is `placeId`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// 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,
      core.String $fields}) {
    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];
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _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.
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;
  }
}

/// This resource represents a long-running operation that is the result of a
/// network API call.
class Operation {
  /// If the value is `false`, it means the operation is still in progress.
  /// If `true`, the operation is completed, and either `error` or `response` is
  /// available.
  core.bool done;

  /// The error result of the operation in case of failure or cancellation.
  Status error;

  /// Service-specific metadata associated with the operation.  It typically
  /// contains progress information and common metadata such as create time.
  /// Some services might not provide such metadata.  Any method that returns a
  /// long-running operation should document the metadata type, if any.
  ///
  /// 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.Map<core.String, core.Object> metadata;

  /// The server-assigned name, which is only unique within the same service
  /// that
  /// originally returns it. If you use the default HTTP mapping, the
  /// `name` should have the format of `operations/some/unique/name`.
  core.String name;

  /// The normal response of the operation in case of success.  If the original
  /// method returns no data on success, such as `Delete`, the response is
  /// `google.protobuf.Empty`.  If the original method is standard
  /// `Get`/`Create`/`Update`, the response should be the resource.  For other
  /// methods, the response should have the type `XxxResponse`, where `Xxx`
  /// is the original method name.  For example, if the original method name
  /// is `TakeSnapshot()`, the inferred response type is
  /// `TakeSnapshotResponse`.
  ///
  /// 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.Map<core.String, core.Object> response;

  Operation();

  Operation.fromJson(core.Map _json) {
    if (_json.containsKey("done")) {
      done = _json["done"];
    }
    if (_json.containsKey("error")) {
      error = new Status.fromJson(_json["error"]);
    }
    if (_json.containsKey("metadata")) {
      metadata = _json["metadata"];
    }
    if (_json.containsKey("name")) {
      name = _json["name"];
    }
    if (_json.containsKey("response")) {
      response = _json["response"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (done != null) {
      _json["done"] = done;
    }
    if (error != null) {
      _json["error"] = (error).toJson();
    }
    if (metadata != null) {
      _json["metadata"] = metadata;
    }
    if (name != null) {
      _json["name"] = name;
    }
    if (response != null) {
      _json["response"] = response;
    }
    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 a photo. Output only when creating a 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 a 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 unique identifier for a photo.
  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 {
  /// 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 WGS84 ellipsoid.
  /// 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.
  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 `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;
  }
}