generated/googleapis/lib/runtimeconfig/v1.dart - third_party/googleapis.dart - Git at Google

 // This is a generated file (see the discoveryapis_generator project).

 // ignore_for_file: unused_import, unnecessary_cast

 library googleapis.runtimeconfig.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 runtimeconfig/v1';

 /// The Runtime Configurator allows you to dynamically configure and expose
 /// variables through Google Cloud Platform. In addition, you can also set
 /// Watchers and Waiters that will watch for changes to your data and return
 /// based on certain conditions.
 class RuntimeconfigApi {
   /// View and manage your data across Google Cloud Platform services
   static const CloudPlatformScope =
       "https://www.googleapis.com/auth/cloud-platform";

   /// Manage your Google Cloud Platform services' runtime configuration
   static const CloudruntimeconfigScope =
       "https://www.googleapis.com/auth/cloudruntimeconfig";

   final commons.ApiRequester _requester;

   OperationsResourceApi get operations => new OperationsResourceApi(_requester);

   RuntimeconfigApi(http.Client client,
       {core.String rootUrl = "https://runtimeconfig.googleapis.com/",
       core.String servicePath = ""})
       : _requester =
             new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }

 class OperationsResourceApi {
   final commons.ApiRequester _requester;

   OperationsResourceApi(commons.ApiRequester client) : _requester = client;

   /// Starts asynchronous cancellation on a long-running operation. The server
   /// makes a best effort to cancel the operation, but success is not
   /// guaranteed. If the server doesn't support this method, it returns
   /// `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation
   /// or other methods to check whether the cancellation succeeded or whether
   /// the operation completed despite cancellation. On successful cancellation,
   /// the operation is not deleted; instead, it becomes an operation with an
   /// Operation.error value with a google.rpc.Status.code of 1, corresponding to
   /// `Code.CANCELLED`.
   ///
   /// [request] - The metadata request object.
   ///
   /// Request parameters:
   ///
   /// [name] - The name of the operation resource to be cancelled.
   /// Value must have pattern "^operations/.*$".
   ///
   /// [$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> cancel(CancelOperationRequest request, core.String name,
       {core.String $fields}) {
     var _url;
     var _queryParams = new core.Map<core.String, core.List<core.String>>();
     var _uploadMedia;
     var _uploadOptions;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body;

     if (request != null) {
       _body = convert.json.encode((request).toJson());
     }
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
     if ($fields != null) {
       _queryParams["fields"] = [$fields];
     }

     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + ':cancel';

     var _response = _requester.request(_url, "POST",
         body: _body,
         queryParams: _queryParams,
         uploadOptions: _uploadOptions,
         uploadMedia: _uploadMedia,
         downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }

   /// Deletes a long-running operation. This method indicates that the client is
   /// no longer interested in the operation result. It does not cancel the
   /// operation. If the server doesn't support this method, it returns
   /// `google.rpc.Code.UNIMPLEMENTED`.
   ///
   /// Request parameters:
   ///
   /// [name] - The name of the operation resource to be deleted.
   /// Value must have pattern "^operations/.*$".
   ///
   /// [$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 name, {core.String $fields}) {
     var _url;
     var _queryParams = new core.Map<core.String, core.List<core.String>>();
     var _uploadMedia;
     var _uploadOptions;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body;

     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
     if ($fields != null) {
       _queryParams["fields"] = [$fields];
     }

     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');

     var _response = _requester.request(_url, "DELETE",
         body: _body,
         queryParams: _queryParams,
         uploadOptions: _uploadOptions,
         uploadMedia: _uploadMedia,
         downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }

   /// Lists operations that match the specified filter in the request. If the
   /// server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the
   /// `name` binding allows API services to override the binding to use
   /// different resource name schemes, such as `users / * /operations`. To
   /// override the binding, API services can add a binding such as
   /// `"/v1/{name=users / * }/operations"` to their service configuration. For
   /// backwards compatibility, the default name includes the operations
   /// collection id, however overriding users must ensure the name binding is
   /// the parent resource, without the operations collection id.
   ///
   /// Request parameters:
   ///
   /// [name] - The name of the operation's parent resource.
   /// Value must have pattern "^operations$".
   ///
   /// [pageToken] - The standard list page token.
   ///
   /// [pageSize] - The standard list page size.
   ///
   /// [filter] - The standard list filter.
   ///
   /// [$fields] - Selector specifying which fields to include in a partial
   /// response.
   ///
   /// Completes with a [ListOperationsResponse].
   ///
   /// 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<ListOperationsResponse> list(core.String name,
       {core.String pageToken,
       core.int pageSize,
       core.String filter,
       core.String $fields}) {
     var _url;
     var _queryParams = new core.Map<core.String, core.List<core.String>>();
     var _uploadMedia;
     var _uploadOptions;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body;

     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if ($fields != null) {
       _queryParams["fields"] = [$fields];
     }

     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');

     var _response = _requester.request(_url, "GET",
         body: _body,
         queryParams: _queryParams,
         uploadOptions: _uploadOptions,
         uploadMedia: _uploadMedia,
         downloadOptions: _downloadOptions);
     return _response.then((data) => new ListOperationsResponse.fromJson(data));
   }
 }

 /// The request message for Operations.CancelOperation.
 class CancelOperationRequest {
   CancelOperationRequest();

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

 /// 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;
   }
 }

 /// The response message for Operations.ListOperations.
 class ListOperationsResponse {
   /// The standard List next-page token.
   core.String nextPageToken;

   /// A list of operations that matches the specified filter in the request.
   core.List<Operation> operations;

   ListOperationsResponse();

   ListOperationsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("operations")) {
       operations = (_json["operations"] as core.List)
           .map<Operation>((value) => new Operation.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 (operations != null) {
       _json["operations"] =
           operations.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 be a resource name ending with `operations/{unique_id}`.
   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"] as core.Map).cast<core.String, core.Object>();
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
     if (_json.containsKey("response")) {
       response =
           (_json["response"] as core.Map).cast<core.String, core.Object>();
     }
   }

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

 /// 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). Each `Status` message contains
 /// three pieces of data: error code, error message, and error details. You can
 /// find out more about this error model and how to work with it in the [API
 /// Design Guide](https://cloud.google.com/apis/design/errors).
 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"] as core.List)
           .map<core.Map<core.String, core.Object>>(
               (value) => (value as core.Map).cast<core.String, core.Object>())
           .toList();
     }
     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;
   }
 }
	// This is a generated file (see the discoveryapis_generator project).

	// ignore_for_file: unused_import, unnecessary_cast

	library googleapis.runtimeconfig.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 runtimeconfig/v1';

	/// The Runtime Configurator allows you to dynamically configure and expose
	/// variables through Google Cloud Platform. In addition, you can also set
	/// Watchers and Waiters that will watch for changes to your data and return
	/// based on certain conditions.
	class RuntimeconfigApi {
	/// View and manage your data across Google Cloud Platform services
	static const CloudPlatformScope =
	"https://www.googleapis.com/auth/cloud-platform";

	/// Manage your Google Cloud Platform services' runtime configuration
	static const CloudruntimeconfigScope =
	"https://www.googleapis.com/auth/cloudruntimeconfig";

	final commons.ApiRequester _requester;

	OperationsResourceApi get operations => new OperationsResourceApi(_requester);

	RuntimeconfigApi(http.Client client,
	{core.String rootUrl = "https://runtimeconfig.googleapis.com/",
	core.String servicePath = ""})
	: _requester =
	new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
	}

	class OperationsResourceApi {
	final commons.ApiRequester _requester;

	OperationsResourceApi(commons.ApiRequester client) : _requester = client;

	/// Starts asynchronous cancellation on a long-running operation. The server
	/// makes a best effort to cancel the operation, but success is not
	/// guaranteed. If the server doesn't support this method, it returns
	/// `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation
	/// or other methods to check whether the cancellation succeeded or whether
	/// the operation completed despite cancellation. On successful cancellation,
	/// the operation is not deleted; instead, it becomes an operation with an
	/// Operation.error value with a google.rpc.Status.code of 1, corresponding to
	/// `Code.CANCELLED`.
	///
	/// [request] - The metadata request object.
	///
	/// Request parameters:
	///
	/// [name] - The name of the operation resource to be cancelled.
	/// Value must have pattern "^operations/.*$".
	///
	/// [$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> cancel(CancelOperationRequest request, core.String name,
	{core.String $fields}) {
	var _url;
	var _queryParams = new core.Map<core.String, core.List<core.String>>();
	var _uploadMedia;
	var _uploadOptions;
	var _downloadOptions = commons.DownloadOptions.Metadata;
	var _body;

	if (request != null) {
	_body = convert.json.encode((request).toJson());
	}
	if (name == null) {
	throw new core.ArgumentError("Parameter name is required.");
	}
	if ($fields != null) {
	_queryParams["fields"] = [$fields];
	}

	_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + ':cancel';

	var _response = _requester.request(_url, "POST",
	body: _body,
	queryParams: _queryParams,
	uploadOptions: _uploadOptions,
	uploadMedia: _uploadMedia,
	downloadOptions: _downloadOptions);
	return _response.then((data) => new Empty.fromJson(data));
	}

	/// Deletes a long-running operation. This method indicates that the client is
	/// no longer interested in the operation result. It does not cancel the
	/// operation. If the server doesn't support this method, it returns
	/// `google.rpc.Code.UNIMPLEMENTED`.
	///
	/// Request parameters:
	///
	/// [name] - The name of the operation resource to be deleted.
	/// Value must have pattern "^operations/.*$".
	///
	/// [$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 name, {core.String $fields}) {
	var _url;
	var _queryParams = new core.Map<core.String, core.List<core.String>>();
	var _uploadMedia;
	var _uploadOptions;
	var _downloadOptions = commons.DownloadOptions.Metadata;
	var _body;

	if (name == null) {
	throw new core.ArgumentError("Parameter name is required.");
	}
	if ($fields != null) {
	_queryParams["fields"] = [$fields];
	}

	_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');

	var _response = _requester.request(_url, "DELETE",
	body: _body,
	queryParams: _queryParams,
	uploadOptions: _uploadOptions,
	uploadMedia: _uploadMedia,
	downloadOptions: _downloadOptions);
	return _response.then((data) => new Empty.fromJson(data));
	}

	/// Lists operations that match the specified filter in the request. If the
	/// server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the
	/// `name` binding allows API services to override the binding to use
	/// different resource name schemes, such as `users / * /operations`. To
	/// override the binding, API services can add a binding such as
	/// `"/v1/{name=users / * }/operations"` to their service configuration. For
	/// backwards compatibility, the default name includes the operations
	/// collection id, however overriding users must ensure the name binding is
	/// the parent resource, without the operations collection id.
	///
	/// Request parameters:
	///
	/// [name] - The name of the operation's parent resource.
	/// Value must have pattern "^operations$".
	///
	/// [pageToken] - The standard list page token.
	///
	/// [pageSize] - The standard list page size.
	///
	/// [filter] - The standard list filter.
	///
	/// [$fields] - Selector specifying which fields to include in a partial
	/// response.
	///
	/// Completes with a [ListOperationsResponse].
	///
	/// 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<ListOperationsResponse> list(core.String name,
	{core.String pageToken,
	core.int pageSize,
	core.String filter,
	core.String $fields}) {
	var _url;
	var _queryParams = new core.Map<core.String, core.List<core.String>>();
	var _uploadMedia;
	var _uploadOptions;
	var _downloadOptions = commons.DownloadOptions.Metadata;
	var _body;

	if (name == null) {
	throw new core.ArgumentError("Parameter name is required.");
	}
	if (pageToken != null) {
	_queryParams["pageToken"] = [pageToken];
	}
	if (pageSize != null) {
	_queryParams["pageSize"] = ["${pageSize}"];
	}
	if (filter != null) {
	_queryParams["filter"] = [filter];
	}
	if ($fields != null) {
	_queryParams["fields"] = [$fields];
	}

	_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');

	var _response = _requester.request(_url, "GET",
	body: _body,
	queryParams: _queryParams,
	uploadOptions: _uploadOptions,
	uploadMedia: _uploadMedia,
	downloadOptions: _downloadOptions);
	return _response.then((data) => new ListOperationsResponse.fromJson(data));
	}
	}

	/// The request message for Operations.CancelOperation.
	class CancelOperationRequest {
	CancelOperationRequest();

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

	/// 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;
	}
	}

	/// The response message for Operations.ListOperations.
	class ListOperationsResponse {
	/// The standard List next-page token.
	core.String nextPageToken;

	/// A list of operations that matches the specified filter in the request.
	core.List<Operation> operations;

	ListOperationsResponse();

	ListOperationsResponse.fromJson(core.Map _json) {
	if (_json.containsKey("nextPageToken")) {
	nextPageToken = _json["nextPageToken"];
	}
	if (_json.containsKey("operations")) {
	operations = (_json["operations"] as core.List)
	.map<Operation>((value) => new Operation.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 (operations != null) {
	_json["operations"] =
	operations.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 be a resource name ending with `operations/{unique_id}`.
	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"] as core.Map).cast<core.String, core.Object>();
	}
	if (_json.containsKey("name")) {
	name = _json["name"];
	}
	if (_json.containsKey("response")) {
	response =
	(_json["response"] as core.Map).cast<core.String, core.Object>();
	}
	}

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

	/// 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). Each `Status` message contains
	/// three pieces of data: error code, error message, and error details. You can
	/// find out more about this error model and how to work with it in the [API
	/// Design Guide](https://cloud.google.com/apis/design/errors).
	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"] as core.List)
	.map<core.Map<core.String, core.Object>>(
	(value) => (value as core.Map).cast<core.String, core.Object>())
	.toList();
	}
	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;
	}
	}