Google Git
Sign in
flutter / third_party / googleapis.dart / b223bd5012b9ac23ec29d771476e115aa803650b / . / generated / googleapis / lib / cloudtasks / v2.dart
blob: b32a6fa67341876ddda5f8932fc640b5a9ce2299 [file] [log] [blame]
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: unused_import, unnecessary_cast
library googleapis.cloudtasks.v2;
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 cloudtasks/v2';
/// Manages the execution of large numbers of distributed requests.
class CloudtasksApi {
/// View and manage your data across Google Cloud Platform services
static const CloudPlatformScope =
"https://www.googleapis.com/auth/cloud-platform";
final commons.ApiRequester _requester;
ProjectsResourceApi get projects => new ProjectsResourceApi(_requester);
CloudtasksApi(http.Client client,
{core.String rootUrl = "https://cloudtasks.googleapis.com/",
core.String servicePath = ""})
: _requester =
new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
}
class ProjectsResourceApi {
final commons.ApiRequester _requester;
ProjectsLocationsResourceApi get locations =>
new ProjectsLocationsResourceApi(_requester);
ProjectsResourceApi(commons.ApiRequester client) : _requester = client;
}
class ProjectsLocationsResourceApi {
final commons.ApiRequester _requester;
ProjectsLocationsQueuesResourceApi get queues =>
new ProjectsLocationsQueuesResourceApi(_requester);
ProjectsLocationsResourceApi(commons.ApiRequester client)
: _requester = client;
/// Gets information about a location.
///
/// Request parameters:
///
/// [name] - Resource name for the location.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Location].
///
/// 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<Location> get(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 = 'v2/' + 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 Location.fromJson(data));
}
/// Lists information about the supported locations for this service.
///
/// Request parameters:
///
/// [name] - The resource that owns the locations collection, if applicable.
/// Value must have pattern "^projects/[^/]+$".
///
/// [pageSize] - The standard list page size.
///
/// [filter] - The standard list filter.
///
/// [pageToken] - The standard list page token.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListLocationsResponse].
///
/// 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<ListLocationsResponse> list(core.String name,
{core.int pageSize,
core.String filter,
core.String pageToken,
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 (pageSize != null) {
_queryParams["pageSize"] = ["${pageSize}"];
}
if (filter != null) {
_queryParams["filter"] = [filter];
}
if (pageToken != null) {
_queryParams["pageToken"] = [pageToken];
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url =
'v2/' + commons.Escaper.ecapeVariableReserved('$name') + '/locations';
var _response = _requester.request(_url, "GET",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new ListLocationsResponse.fromJson(data));
}
}
class ProjectsLocationsQueuesResourceApi {
final commons.ApiRequester _requester;
ProjectsLocationsQueuesTasksResourceApi get tasks =>
new ProjectsLocationsQueuesTasksResourceApi(_requester);
ProjectsLocationsQueuesResourceApi(commons.ApiRequester client)
: _requester = client;
/// Creates a queue. Queues created with this method allow tasks to live for a
/// maximum of 31 days. After a task is 31 days old, the task will be deleted
/// regardless of whether it was dispatched or not. WARNING: Using this method
/// may have unintended side effects if you are using an App Engine
/// `queue.yaml` or `queue.xml` file to manage your queues. Read [Overview of
/// Queue Management and
/// queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using
/// this method.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - Required. The location name in which the queue will be created.
/// For example: `projects/PROJECT_ID/locations/LOCATION_ID` The list of
/// allowed locations can be obtained by calling Cloud Tasks' implementation
/// of ListLocations.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Queue].
///
/// 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<Queue> create(Queue request, core.String parent,
{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 (parent == null) {
throw new core.ArgumentError("Parameter parent is required.");
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' + commons.Escaper.ecapeVariableReserved('$parent') + '/queues';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Queue.fromJson(data));
}
/// Deletes a queue. This command will delete the queue even if it has tasks
/// in it. Note: If you delete a queue, a queue with the same name can't be
/// created for 7 days. WARNING: Using this method may have unintended side
/// effects if you are using an App Engine `queue.yaml` or `queue.xml` file to
/// manage your queues. Read [Overview of Queue Management and
/// queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using
/// this method.
///
/// Request parameters:
///
/// [name] - Required. The queue name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$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 = 'v2/' + 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));
}
/// Gets a queue.
///
/// Request parameters:
///
/// [name] - Required. The resource name of the queue. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Queue].
///
/// 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<Queue> get(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 = 'v2/' + 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 Queue.fromJson(data));
}
/// Gets the access control policy for a Queue. Returns an empty policy if the
/// resource exists and does not have a policy set. Authorization requires the
/// following [Google IAM](https://cloud.google.com/iam) permission on the
/// specified resource parent: * `cloudtasks.queues.getIamPolicy`
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Policy].
///
/// 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<Policy> getIamPolicy(
GetIamPolicyRequest request, core.String resource,
{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 (resource == null) {
throw new core.ArgumentError("Parameter resource is required.");
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':getIamPolicy';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Policy.fromJson(data));
}
/// Lists queues. Queues are returned in lexicographical order.
///
/// Request parameters:
///
/// [parent] - Required. The location name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+$".
///
/// [pageToken] - A token identifying the page of results to return. To
/// request the first page results, page_token must be empty. To request the
/// next page of results, page_token must be the value of next_page_token
/// returned from the previous call to ListQueues method. It is an error to
/// switch the value of the filter while iterating through pages.
///
/// [pageSize] - Requested page size. The maximum page size is 9800. If
/// unspecified, the page size will be the maximum. Fewer queues than
/// requested might be returned, even if more queues exist; use the
/// next_page_token in the response to determine if more queues exist.
///
/// [filter] - `filter` can be used to specify a subset of queues. Any Queue
/// field can be used as a filter and several operators as supported. For
/// example: `<=, <, >=, >, !=, =, :`. The filter syntax is the same as
/// described in [Stackdriver's Advanced Logs
/// Filters](https://cloud.google.com/logging/docs/view/advanced_filters).
/// Sample filter "state: PAUSED". Note that using filters might cause fewer
/// queues than the requested page_size to be returned.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListQueuesResponse].
///
/// 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<ListQueuesResponse> list(core.String parent,
{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 (parent == null) {
throw new core.ArgumentError("Parameter parent 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 = 'v2/' + commons.Escaper.ecapeVariableReserved('$parent') + '/queues';
var _response = _requester.request(_url, "GET",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new ListQueuesResponse.fromJson(data));
}
/// Updates a queue. This method creates the queue if it does not exist and
/// updates the queue if it does exist. Queues created with this method allow
/// tasks to live for a maximum of 31 days. After a task is 31 days old, the
/// task will be deleted regardless of whether it was dispatched or not.
/// WARNING: Using this method may have unintended side effects if you are
/// using an App Engine `queue.yaml` or `queue.xml` file to manage your
/// queues. Read [Overview of Queue Management and
/// queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using
/// this method.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Caller-specified and required in CreateQueue, after which it
/// becomes output only. The queue name. The queue name must have the
/// following format:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID` * `PROJECT_ID`
/// can contain letters ([A-Za-z]), numbers ([0-9]), hyphens (-), colons (:),
/// or periods (.). For more information, see [Identifying
/// projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)
/// * `LOCATION_ID` is the canonical ID for the queue's location. The list of
/// available locations can be obtained by calling ListLocations. For more
/// information, see https://cloud.google.com/about/locations/. * `QUEUE_ID`
/// can contain letters ([A-Za-z]), numbers ([0-9]), or hyphens (-). The
/// maximum length is 100 characters.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [updateMask] - A mask used to specify which fields of the queue are being
/// updated. If empty, then all fields will be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Queue].
///
/// 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<Queue> patch(Queue request, core.String name,
{core.String updateMask, 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 (updateMask != null) {
_queryParams["updateMask"] = [updateMask];
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' + commons.Escaper.ecapeVariableReserved('$name');
var _response = _requester.request(_url, "PATCH",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Queue.fromJson(data));
}
/// Pauses the queue. If a queue is paused then the system will stop
/// dispatching tasks until the queue is resumed via ResumeQueue. Tasks can
/// still be added when the queue is paused. A queue is paused if its state is
/// PAUSED.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Required. The queue name. For example:
/// `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Queue].
///
/// 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<Queue> pause(PauseQueueRequest 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 = 'v2/' + commons.Escaper.ecapeVariableReserved('$name') + ':pause';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Queue.fromJson(data));
}
/// Purges a queue by deleting all of its tasks. All tasks created before this
/// method is called are permanently deleted. Purge operations can take up to
/// one minute to take effect. Tasks might be dispatched before the purge
/// takes effect. A purge is irreversible.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Required. The queue name. For example:
/// `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Queue].
///
/// 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<Queue> purge(PurgeQueueRequest 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 = 'v2/' + commons.Escaper.ecapeVariableReserved('$name') + ':purge';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Queue.fromJson(data));
}
/// Resume a queue. This method resumes a queue after it has been PAUSED or
/// DISABLED. The state of a queue is stored in the queue's state; after
/// calling this method it will be set to RUNNING. WARNING: Resuming many
/// high-QPS queues at the same time can lead to target overloading. If you
/// are resuming high-QPS queues, follow the 500/50/5 pattern described in
/// [Managing Cloud Tasks Scaling
/// Risks](https://cloud.google.com/tasks/docs/manage-cloud-task-scaling).
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Required. The queue name. For example:
/// `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Queue].
///
/// 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<Queue> resume(ResumeQueueRequest 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 = 'v2/' + commons.Escaper.ecapeVariableReserved('$name') + ':resume';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Queue.fromJson(data));
}
/// Sets the access control policy for a Queue. Replaces any existing policy.
/// Note: The Cloud Console does not check queue-level IAM permissions yet.
/// Project-level permissions are required to use the Cloud Console.
/// Authorization requires the following [Google
/// IAM](https://cloud.google.com/iam) permission on the specified resource
/// parent: * `cloudtasks.queues.setIamPolicy`
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// specified. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Policy].
///
/// 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<Policy> setIamPolicy(
SetIamPolicyRequest request, core.String resource,
{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 (resource == null) {
throw new core.ArgumentError("Parameter resource is required.");
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':setIamPolicy';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Policy.fromJson(data));
}
/// Returns permissions that a caller has on a Queue. If the resource does not
/// exist, this will return an empty set of permissions, not a NOT_FOUND
/// error. Note: This operation is designed to be used for building
/// permission-aware UIs and command-line tools, not for authorization
/// checking. This operation may "fail open" without warning.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy detail is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [TestIamPermissionsResponse].
///
/// 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<TestIamPermissionsResponse> testIamPermissions(
TestIamPermissionsRequest request, core.String resource,
{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 (resource == null) {
throw new core.ArgumentError("Parameter resource is required.");
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':testIamPermissions';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response
.then((data) => new TestIamPermissionsResponse.fromJson(data));
}
}
class ProjectsLocationsQueuesTasksResourceApi {
final commons.ApiRequester _requester;
ProjectsLocationsQueuesTasksResourceApi(commons.ApiRequester client)
: _requester = client;
/// Creates a task and adds it to a queue. Tasks cannot be updated after
/// creation; there is no UpdateTask command. * The maximum task size is
/// 100KB.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - Required. The queue name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID` The queue must
/// already exist.
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Task].
///
/// 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<Task> create(CreateTaskRequest request, core.String parent,
{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 (parent == null) {
throw new core.ArgumentError("Parameter parent is required.");
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' + commons.Escaper.ecapeVariableReserved('$parent') + '/tasks';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Task.fromJson(data));
}
/// Deletes a task. A task can be deleted if it is scheduled or dispatched. A
/// task cannot be deleted if it has executed successfully or permanently
/// failed.
///
/// Request parameters:
///
/// [name] - Required. The task name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
/// Value must have pattern
/// "^projects/[^/]+/locations/[^/]+/queues/[^/]+/tasks/[^/]+$".
///
/// [$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 = 'v2/' + 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));
}
/// Gets a task.
///
/// Request parameters:
///
/// [name] - Required. The task name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
/// Value must have pattern
/// "^projects/[^/]+/locations/[^/]+/queues/[^/]+/tasks/[^/]+$".
///
/// [responseView] - The response_view specifies which subset of the Task will
/// be returned. By default response_view is BASIC; not all information is
/// retrieved by default because some data, such as payloads, might be
/// desirable to return only when needed because of its large size or because
/// of the sensitivity of data that it contains. Authorization for FULL
/// requires `cloudtasks.tasks.fullView` [Google
/// IAM](https://cloud.google.com/iam/) permission on the Task resource.
/// Possible string values are:
/// - "VIEW_UNSPECIFIED" : Unspecified. Defaults to BASIC.
/// - "BASIC" : The basic view omits fields which can be large or can contain
/// sensitive data. This view does not include the body in
/// AppEngineHttpRequest. Bodies are desirable to return only when needed,
/// because they can be large and because of the sensitivity of the data that
/// you choose to store in it.
/// - "FULL" : All information is returned. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Queue resource.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Task].
///
/// 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<Task> get(core.String name,
{core.String responseView, 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 (responseView != null) {
_queryParams["responseView"] = [responseView];
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' + 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 Task.fromJson(data));
}
/// Lists the tasks in a queue. By default, only the BASIC view is retrieved
/// due to performance considerations; response_view controls the subset of
/// information which is returned. The tasks may be returned in any order. The
/// ordering may change at any time.
///
/// Request parameters:
///
/// [parent] - Required. The queue name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
/// Value must have pattern "^projects/[^/]+/locations/[^/]+/queues/[^/]+$".
///
/// [responseView] - The response_view specifies which subset of the Task will
/// be returned. By default response_view is BASIC; not all information is
/// retrieved by default because some data, such as payloads, might be
/// desirable to return only when needed because of its large size or because
/// of the sensitivity of data that it contains. Authorization for FULL
/// requires `cloudtasks.tasks.fullView` [Google
/// IAM](https://cloud.google.com/iam/) permission on the Task resource.
/// Possible string values are:
/// - "VIEW_UNSPECIFIED" : Unspecified. Defaults to BASIC.
/// - "BASIC" : The basic view omits fields which can be large or can contain
/// sensitive data. This view does not include the body in
/// AppEngineHttpRequest. Bodies are desirable to return only when needed,
/// because they can be large and because of the sensitivity of the data that
/// you choose to store in it.
/// - "FULL" : All information is returned. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Queue resource.
///
/// [pageToken] - A token identifying the page of results to return. To
/// request the first page results, page_token must be empty. To request the
/// next page of results, page_token must be the value of next_page_token
/// returned from the previous call to ListTasks method. The page token is
/// valid for only 2 hours.
///
/// [pageSize] - Maximum page size. Fewer tasks than requested might be
/// returned, even if more tasks exist; use next_page_token in the response to
/// determine if more tasks exist. The maximum page size is 1000. If
/// unspecified, the page size will be the maximum.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListTasksResponse].
///
/// 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<ListTasksResponse> list(core.String parent,
{core.String responseView,
core.String pageToken,
core.int pageSize,
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 (parent == null) {
throw new core.ArgumentError("Parameter parent is required.");
}
if (responseView != null) {
_queryParams["responseView"] = [responseView];
}
if (pageToken != null) {
_queryParams["pageToken"] = [pageToken];
}
if (pageSize != null) {
_queryParams["pageSize"] = ["${pageSize}"];
}
if ($fields != null) {
_queryParams["fields"] = [$fields];
}
_url = 'v2/' + commons.Escaper.ecapeVariableReserved('$parent') + '/tasks';
var _response = _requester.request(_url, "GET",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new ListTasksResponse.fromJson(data));
}
/// Forces a task to run now. When this method is called, Cloud Tasks will
/// dispatch the task, even if the task is already running, the queue has
/// reached its RateLimits or is PAUSED. This command is meant to be used for
/// manual debugging. For example, RunTask can be used to retry a failed task
/// after a fix has been made or to manually force a task to be dispatched
/// now. The dispatched task is returned. That is, the task that is returned
/// contains the status after the task is dispatched but before the task is
/// received by its target. If Cloud Tasks receives a successful response from
/// the task's target, then the task will be deleted; otherwise the task's
/// schedule_time will be reset to the time that RunTask was called plus the
/// retry delay specified in the queue's RetryConfig. RunTask returns
/// NOT_FOUND when it is called on a task that has already succeeded or
/// permanently failed.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Required. The task name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
/// Value must have pattern
/// "^projects/[^/]+/locations/[^/]+/queues/[^/]+/tasks/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Task].
///
/// 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<Task> run(RunTaskRequest 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 = 'v2/' + commons.Escaper.ecapeVariableReserved('$name') + ':run';
var _response = _requester.request(_url, "POST",
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions);
return _response.then((data) => new Task.fromJson(data));
}
}
/// App Engine HTTP request. The message defines the HTTP request that is sent
/// to an App Engine app when the task is dispatched. Using AppEngineHttpRequest
/// requires
/// [`appengine.applications.get`](https://cloud.google.com/appengine/docs/admin-api/access-control)
/// Google IAM permission for the project and the following scope:
/// `https://www.googleapis.com/auth/cloud-platform` The task will be delivered
/// to the App Engine app which belongs to the same project as the queue. For
/// more information, see [How Requests are
/// Routed](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed)
/// and how routing is affected by [dispatch
/// files](https://cloud.google.com/appengine/docs/python/config/dispatchref).
/// Traffic is encrypted during transport and never leaves Google datacenters.
/// Because this traffic is carried over a communication mechanism internal to
/// Google, you cannot explicitly set the protocol (for example, HTTP or HTTPS).
/// The request to the handler, however, will appear to have used the HTTP
/// protocol. The AppEngineRouting used to construct the URL that the task is
/// delivered to can be set at the queue-level or task-level: * If
/// app_engine_routing_override is set on the queue, this value is used for all
/// tasks in the queue, no matter what the setting is for the task-level
/// app_engine_routing. The `url` that the task will be sent to is: * `url =`
/// host `+` relative_uri Tasks can be dispatched to secure app handlers,
/// unsecure app handlers, and URIs restricted with [`login:
/// admin`](https://cloud.google.com/appengine/docs/standard/python/config/appref).
/// Because tasks are not run as any user, they cannot be dispatched to URIs
/// restricted with [`login:
/// required`](https://cloud.google.com/appengine/docs/standard/python/config/appref)
/// Task dispatches also do not follow redirects. The task attempt has succeeded
/// if the app's request handler returns an HTTP response code in the range
/// [`200` - `299`]. The task attempt has failed if the app's handler returns a
/// non-2xx response code or Cloud Tasks does not receive response before the
/// deadline. Failed tasks will be retried according to the retry configuration.
/// `503` (Service Unavailable) is considered an App Engine system error instead
/// of an application error and will cause Cloud Tasks' traffic congestion
/// control to temporarily throttle the queue's dispatches. Unlike other types
/// of task targets, a `429` (Too Many Requests) response from an app handler
/// does not cause traffic congestion control to throttle the queue.
class AppEngineHttpRequest {
/// Task-level setting for App Engine routing. * If
/// app_engine_routing_override is set on the queue, this value is used for
/// all tasks in the queue, no matter what the setting is for the task-level
/// app_engine_routing.
AppEngineRouting appEngineRouting;
/// HTTP request body. A request body is allowed only if the HTTP method is
/// POST or PUT. It is an error to set a body on a task with an incompatible
/// HttpMethod.
core.String body;
core.List<core.int> get bodyAsBytes {
return convert.base64.decode(body);
}
set bodyAsBytes(core.List<core.int> _bytes) {
body =
convert.base64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
}
/// HTTP request headers. This map contains the header field names and values.
/// Headers can be set when the task is created. Repeated headers are not
/// supported but a header value can contain commas. Cloud Tasks sets some
/// headers to default values: * `User-Agent`: By default, this header is
/// `"AppEngine-Google; (+http://code.google.com/appengine)"`. This header can
/// be modified, but Cloud Tasks will append `"AppEngine-Google;
/// (+http://code.google.com/appengine)"` to the modified `User-Agent`. If the
/// task has a body, Cloud Tasks sets the following headers: * `Content-Type`:
/// By default, the `Content-Type` header is set to
/// `"application/octet-stream"`. The default can be overridden by explicitly
/// setting `Content-Type` to a particular media type when the task is
/// created. For example, `Content-Type` can be set to `"application/json"`. *
/// `Content-Length`: This is computed by Cloud Tasks. This value is output
/// only. It cannot be changed. The headers below cannot be set or overridden:
/// * `Host` * `X-Google-*` * `X-AppEngine-*` In addition, Cloud Tasks sets
/// some headers when the task is dispatched, such as headers containing
/// information about the task; see [request
/// headers](https://cloud.google.com/tasks/docs/creating-appengine-handlers#reading_request_headers).
/// These headers are set only when the task is dispatched, so they are not
/// visible when the task is returned in a Cloud Tasks response. Although
/// there is no specific limit for the maximum number of headers or the size,
/// there is a limit on the maximum size of the Task. For more information,
/// see the CreateTask documentation.
core.Map<core.String, core.String> headers;
/// The HTTP method to use for the request. The default is POST. The app's
/// request handler for the task's target URL must be able to handle HTTP
/// requests with this http_method, otherwise the task attempt fails with
/// error code 405 (Method Not Allowed). See [Writing a push task request
/// handler](https://cloud.google.com/appengine/docs/java/taskqueue/push/creating-handlers#writing_a_push_task_request_handler)
/// and the App Engine documentation for your runtime on [How Requests are
/// Handled](https://cloud.google.com/appengine/docs/standard/python3/how-requests-are-handled).
/// Possible string values are:
/// - "HTTP_METHOD_UNSPECIFIED" : HTTP method unspecified
/// - "POST" : HTTP POST
/// - "GET" : HTTP GET
/// - "HEAD" : HTTP HEAD
/// - "PUT" : HTTP PUT
/// - "DELETE" : HTTP DELETE
/// - "PATCH" : HTTP PATCH
/// - "OPTIONS" : HTTP OPTIONS
core.String httpMethod;
/// The relative URI. The relative URI must begin with "/" and must be a valid
/// HTTP relative URI. It can contain a path and query string arguments. If
/// the relative URI is empty, then the root path "/" will be used. No spaces
/// are allowed, and the maximum length allowed is 2083 characters.
core.String relativeUri;
AppEngineHttpRequest();
AppEngineHttpRequest.fromJson(core.Map _json) {
if (_json.containsKey("appEngineRouting")) {
appEngineRouting =
new AppEngineRouting.fromJson(_json["appEngineRouting"]);
}
if (_json.containsKey("body")) {
body = _json["body"];
}
if (_json.containsKey("headers")) {
headers = (_json["headers"] as core.Map).cast<core.String, core.String>();
}
if (_json.containsKey("httpMethod")) {
httpMethod = _json["httpMethod"];
}
if (_json.containsKey("relativeUri")) {
relativeUri = _json["relativeUri"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (appEngineRouting != null) {
_json["appEngineRouting"] = (appEngineRouting).toJson();
}
if (body != null) {
_json["body"] = body;
}
if (headers != null) {
_json["headers"] = headers;
}
if (httpMethod != null) {
_json["httpMethod"] = httpMethod;
}
if (relativeUri != null) {
_json["relativeUri"] = relativeUri;
}
return _json;
}
}
/// App Engine Routing. Defines routing characteristics specific to App Engine -
/// service, version, and instance. For more information about services,
/// versions, and instances see [An Overview of App
/// Engine](https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine),
/// [Microservices Architecture on Google App
/// Engine](https://cloud.google.com/appengine/docs/python/microservices-on-app-engine),
/// [App Engine Standard request
/// routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed),
/// and [App Engine Flex request
/// routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed).
/// Using AppEngineRouting requires
/// [`appengine.applications.get`](https://cloud.google.com/appengine/docs/admin-api/access-control)
/// Google IAM permission for the project and the following scope:
/// `https://www.googleapis.com/auth/cloud-platform`
class AppEngineRouting {
/// Output only. The host that the task is sent to. The host is constructed
/// from the domain name of the app associated with the queue's project ID
/// (for example .appspot.com), and the service, version, and instance. Tasks
/// which were created using the App Engine SDK might have a custom domain
/// name. For more information, see [How Requests are
/// Routed](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed).
core.String host;
/// App instance. By default, the task is sent to an instance which is
/// available when the task is attempted. Requests can only be sent to a
/// specific instance if [manual scaling is used in App Engine
/// Standard](https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine?hl=en_US#scaling_types_and_instance_classes).
/// App Engine Flex does not support instances. For more information, see [App
/// Engine Standard request
/// routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed)
/// and [App Engine Flex request
/// routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed).
core.String instance;
/// App service. By default, the task is sent to the service which is the
/// default service when the task is attempted. For some queues or tasks which
/// were created using the App Engine Task Queue API, host is not parsable
/// into service, version, and instance. For example, some tasks which were
/// created using the App Engine SDK use a custom domain name; custom domains
/// are not parsed by Cloud Tasks. If host is not parsable, then service,
/// version, and instance are the empty string.
core.String service;
/// App version. By default, the task is sent to the version which is the
/// default version when the task is attempted. For some queues or tasks which
/// were created using the App Engine Task Queue API, host is not parsable
/// into service, version, and instance. For example, some tasks which were
/// created using the App Engine SDK use a custom domain name; custom domains
/// are not parsed by Cloud Tasks. If host is not parsable, then service,
/// version, and instance are the empty string.
core.String version;
AppEngineRouting();
AppEngineRouting.fromJson(core.Map _json) {
if (_json.containsKey("host")) {
host = _json["host"];
}
if (_json.containsKey("instance")) {
instance = _json["instance"];
}
if (_json.containsKey("service")) {
service = _json["service"];
}
if (_json.containsKey("version")) {
version = _json["version"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (host != null) {
_json["host"] = host;
}
if (instance != null) {
_json["instance"] = instance;
}
if (service != null) {
_json["service"] = service;
}
if (version != null) {
_json["version"] = version;
}
return _json;
}
}
/// The status of a task attempt.
class Attempt {
/// Output only. The time that this attempt was dispatched. `dispatch_time`
/// will be truncated to the nearest microsecond.
core.String dispatchTime;
/// Output only. The response from the worker for this attempt. If
/// `response_time` is unset, then the task has not been attempted or is
/// currently running and the `response_status` field is meaningless.
Status responseStatus;
/// Output only. The time that this attempt response was received.
/// `response_time` will be truncated to the nearest microsecond.
core.String responseTime;
/// Output only. The time that this attempt was scheduled. `schedule_time`
/// will be truncated to the nearest microsecond.
core.String scheduleTime;
Attempt();
Attempt.fromJson(core.Map _json) {
if (_json.containsKey("dispatchTime")) {
dispatchTime = _json["dispatchTime"];
}
if (_json.containsKey("responseStatus")) {
responseStatus = new Status.fromJson(_json["responseStatus"]);
}
if (_json.containsKey("responseTime")) {
responseTime = _json["responseTime"];
}
if (_json.containsKey("scheduleTime")) {
scheduleTime = _json["scheduleTime"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (dispatchTime != null) {
_json["dispatchTime"] = dispatchTime;
}
if (responseStatus != null) {
_json["responseStatus"] = (responseStatus).toJson();
}
if (responseTime != null) {
_json["responseTime"] = responseTime;
}
if (scheduleTime != null) {
_json["scheduleTime"] = scheduleTime;
}
return _json;
}
}
/// Associates `members` with a `role`.
class Binding {
/// A client-specified ID for this binding. Expected to be globally unique to
/// support the internal bindings-by-ID API.
core.String bindingId;
/// The condition that is associated with this binding. If the condition
/// evaluates to `true`, then this binding applies to the current request. If
/// the condition evaluates to `false`, then this binding does not apply to
/// the current request. However, a different role binding might grant the
/// same role to one or more of the members in this binding. To learn which
/// resources support conditions in their IAM policies, see the [IAM
/// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
Expr condition;
/// Specifies the identities requesting access for a Cloud Platform resource.
/// `members` can have the following values: * `allUsers`: A special
/// identifier that represents anyone who is on the internet; with or without
/// a Google account. * `allAuthenticatedUsers`: A special identifier that
/// represents anyone who is authenticated with a Google account or a service
/// account. * `user:{emailid}`: An email address that represents a specific
/// Google account. For example, `alice@example.com` . *
/// `serviceAccount:{emailid}`: An email address that represents a service
/// account. For example, `my-other-app@appspot.gserviceaccount.com`. *
/// `group:{emailid}`: An email address that represents a Google group. For
/// example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`:
/// An email address (plus unique identifier) representing a user that has
/// been recently deleted. For example,
/// `alice@example.com?uid=123456789012345678901`. If the user is recovered,
/// this value reverts to `user:{emailid}` and the recovered user retains the
/// role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`:
/// An email address (plus unique identifier) representing a service account
/// that has been recently deleted. For example,
/// `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If
/// the service account is undeleted, this value reverts to
/// `serviceAccount:{emailid}` and the undeleted service account retains the
/// role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email
/// address (plus unique identifier) representing a Google group that has been
/// recently deleted. For example,
/// `admins@example.com?uid=123456789012345678901`. If the group is recovered,
/// this value reverts to `group:{emailid}` and the recovered group retains
/// the role in the binding. * `domain:{domain}`: The G Suite domain (primary)
/// that represents all the users of that domain. For example, `google.com` or
/// `example.com`.
core.List<core.String> members;
/// Role that is assigned to `members`. For example, `roles/viewer`,
/// `roles/editor`, or `roles/owner`.
core.String role;
Binding();
Binding.fromJson(core.Map _json) {
if (_json.containsKey("bindingId")) {
bindingId = _json["bindingId"];
}
if (_json.containsKey("condition")) {
condition = new Expr.fromJson(_json["condition"]);
}
if (_json.containsKey("members")) {
members = (_json["members"] as core.List).cast<core.String>();
}
if (_json.containsKey("role")) {
role = _json["role"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (bindingId != null) {
_json["bindingId"] = bindingId;
}
if (condition != null) {
_json["condition"] = (condition).toJson();
}
if (members != null) {
_json["members"] = members;
}
if (role != null) {
_json["role"] = role;
}
return _json;
}
}
/// Request message for CreateTask.
class CreateTaskRequest {
/// The response_view specifies which subset of the Task will be returned. By
/// default response_view is BASIC; not all information is retrieved by
/// default because some data, such as payloads, might be desirable to return
/// only when needed because of its large size or because of the sensitivity
/// of data that it contains. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Task resource.
/// Possible string values are:
/// - "VIEW_UNSPECIFIED" : Unspecified. Defaults to BASIC.
/// - "BASIC" : The basic view omits fields which can be large or can contain
/// sensitive data. This view does not include the body in
/// AppEngineHttpRequest. Bodies are desirable to return only when needed,
/// because they can be large and because of the sensitivity of the data that
/// you choose to store in it.
/// - "FULL" : All information is returned. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Queue resource.
core.String responseView;
/// Required. The task to add. Task names have the following format:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`.
/// The user can optionally specify a task name. If a name is not specified
/// then the system will generate a random unique task id, which will be set
/// in the task returned in the response. If schedule_time is not set or is in
/// the past then Cloud Tasks will set it to the current time. Task
/// De-duplication: Explicitly specifying a task ID enables task
/// de-duplication. If a task's ID is identical to that of an existing task or
/// a task that was deleted or executed recently then the call will fail with
/// ALREADY_EXISTS. If the task's queue was created using Cloud Tasks, then
/// another task with the same name can't be created for ~1hour after the
/// original task was deleted or executed. If the task's queue was created
/// using queue.yaml or queue.xml, then another task with the same name can't
/// be created for ~9days after the original task was deleted or executed.
/// Because there is an extra lookup cost to identify duplicate task names,
/// these CreateTask calls have significantly increased latency. Using hashed
/// strings for the task id or for the prefix of the task id is recommended.
/// Choosing task ids that are sequential or have sequential prefixes, for
/// example using a timestamp, causes an increase in latency and error rates
/// in all task commands. The infrastructure relies on an approximately
/// uniform distribution of task ids to store and serve tasks efficiently.
Task task;
CreateTaskRequest();
CreateTaskRequest.fromJson(core.Map _json) {
if (_json.containsKey("responseView")) {
responseView = _json["responseView"];
}
if (_json.containsKey("task")) {
task = new Task.fromJson(_json["task"]);
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (responseView != null) {
_json["responseView"] = responseView;
}
if (task != null) {
_json["task"] = (task).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;
}
}
/// Represents a textual expression in the Common Expression Language (CEL)
/// syntax. CEL is a C-like expression language. The syntax and semantics of CEL
/// are documented at https://github.com/google/cel-spec. Example (Comparison):
/// title: "Summary size limit" description: "Determines if a summary is less
/// than 100 chars" expression: "document.summary.size() < 100" Example
/// (Equality): title: "Requestor is owner" description: "Determines if
/// requestor is the document owner" expression: "document.owner ==
/// request.auth.claims.email" Example (Logic): title: "Public documents"
/// description: "Determine whether the document should be publicly visible"
/// expression: "document.type != 'private' && document.type != 'internal'"
/// Example (Data Manipulation): title: "Notification string" description:
/// "Create a notification string with a timestamp." expression: "'New message
/// received at ' + string(document.create_time)" The exact variables and
/// functions that may be referenced within an expression are determined by the
/// service that evaluates it. See the service documentation for additional
/// information.
class Expr {
/// Optional. Description of the expression. This is a longer text which
/// describes the expression, e.g. when hovered over it in a UI.
core.String description;
/// Textual representation of an expression in Common Expression Language
/// syntax.
core.String expression;
/// Optional. String indicating the location of the expression for error
/// reporting, e.g. a file name and a position in the file.
core.String location;
/// Optional. Title for the expression, i.e. a short string describing its
/// purpose. This can be used e.g. in UIs which allow to enter the expression.
core.String title;
Expr();
Expr.fromJson(core.Map _json) {
if (_json.containsKey("description")) {
description = _json["description"];
}
if (_json.containsKey("expression")) {
expression = _json["expression"];
}
if (_json.containsKey("location")) {
location = _json["location"];
}
if (_json.containsKey("title")) {
title = _json["title"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (description != null) {
_json["description"] = description;
}
if (expression != null) {
_json["expression"] = expression;
}
if (location != null) {
_json["location"] = location;
}
if (title != null) {
_json["title"] = title;
}
return _json;
}
}
/// Request message for `GetIamPolicy` method.
class GetIamPolicyRequest {
/// OPTIONAL: A `GetPolicyOptions` object for specifying options to
/// `GetIamPolicy`.
GetPolicyOptions options;
GetIamPolicyRequest();
GetIamPolicyRequest.fromJson(core.Map _json) {
if (_json.containsKey("options")) {
options = new GetPolicyOptions.fromJson(_json["options"]);
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (options != null) {
_json["options"] = (options).toJson();
}
return _json;
}
}
/// Encapsulates settings provided to GetIamPolicy.
class GetPolicyOptions {
/// Optional. The policy format version to be returned. Valid values are 0, 1,
/// and 3. Requests specifying an invalid value will be rejected. Requests for
/// policies with any conditional bindings must specify version 3. Policies
/// without any conditional bindings may specify any valid value or leave the
/// field unset. To learn which resources support conditions in their IAM
/// policies, see the [IAM
/// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
core.int requestedPolicyVersion;
GetPolicyOptions();
GetPolicyOptions.fromJson(core.Map _json) {
if (_json.containsKey("requestedPolicyVersion")) {
requestedPolicyVersion = _json["requestedPolicyVersion"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (requestedPolicyVersion != null) {
_json["requestedPolicyVersion"] = requestedPolicyVersion;
}
return _json;
}
}
/// HTTP request. The task will be pushed to the worker as an HTTP request. If
/// the worker or the redirected worker acknowledges the task by returning a
/// successful HTTP response code ([`200` - `299`]), the task will be removed
/// from the queue. If any other HTTP response code is returned or no response
/// is received, the task will be retried according to the following: *
/// User-specified throttling: retry configuration, rate limits, and the queue's
/// state. * System throttling: To prevent the worker from overloading, Cloud
/// Tasks may temporarily reduce the queue's effective rate. User-specified
/// settings will not be changed. System throttling happens because: * Cloud
/// Tasks backs off on all errors. Normally the backoff specified in rate limits
/// will be used. But if the worker returns `429` (Too Many Requests), `503`
/// (Service Unavailable), or the rate of errors is high, Cloud Tasks will use a
/// higher backoff rate. The retry specified in the `Retry-After` HTTP response
/// header is considered. * To prevent traffic spikes and to smooth sudden
/// increases in traffic, dispatches ramp up slowly when the queue is newly
/// created or idle and if large numbers of tasks suddenly become available to
/// dispatch (due to spikes in create task rates, the queue being unpaused, or
/// many tasks that are scheduled at the same time).
class HttpRequest {
/// HTTP request body. A request body is allowed only if the HTTP method is
/// POST, PUT, or PATCH. It is an error to set body on a task with an
/// incompatible HttpMethod.
core.String body;
core.List<core.int> get bodyAsBytes {
return convert.base64.decode(body);
}
set bodyAsBytes(core.List<core.int> _bytes) {
body =
convert.base64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
}
/// HTTP request headers. This map contains the header field names and values.
/// Headers can be set when the task is created. These headers represent a
/// subset of the headers that will accompany the task's HTTP request. Some
/// HTTP request headers will be ignored or replaced. A partial list of
/// headers that will be ignored or replaced is: * Host: This will be computed
/// by Cloud Tasks and derived from HttpRequest.url. * Content-Length: This
/// will be computed by Cloud Tasks. * User-Agent: This will be set to
/// `"Google-Cloud-Tasks"`. * X-Google-*: Google use only. * X-AppEngine-*:
/// Google use only. `Content-Type` won't be set by Cloud Tasks. You can
/// explicitly set `Content-Type` to a media type when the task is created.
/// For example, `Content-Type` can be set to `"application/octet-stream"` or
/// `"application/json"`. Headers which can have multiple values (according to
/// RFC2616) can be specified using comma-separated values. The size of the
/// headers must be less than 80KB.
core.Map<core.String, core.String> headers;
/// The HTTP method to use for the request. The default is POST.
/// Possible string values are:
/// - "HTTP_METHOD_UNSPECIFIED" : HTTP method unspecified
/// - "POST" : HTTP POST
/// - "GET" : HTTP GET
/// - "HEAD" : HTTP HEAD
/// - "PUT" : HTTP PUT
/// - "DELETE" : HTTP DELETE
/// - "PATCH" : HTTP PATCH
/// - "OPTIONS" : HTTP OPTIONS
core.String httpMethod;
/// If specified, an [OAuth
/// token](https://developers.google.com/identity/protocols/OAuth2) will be
/// generated and attached as an `Authorization` header in the HTTP request.
/// This type of authorization should generally only be used when calling
/// Google APIs hosted on *.googleapis.com.
OAuthToken oauthToken;
/// If specified, an
/// [OIDC](https://developers.google.com/identity/protocols/OpenIDConnect)
/// token will be generated and attached as an `Authorization` header in the
/// HTTP request. This type of authorization can be used for many scenarios,
/// including calling Cloud Run, or endpoints where you intend to validate the
/// token yourself.
OidcToken oidcToken;
/// Required. The full url path that the request will be sent to. This string
/// must begin with either "http://" or "https://". Some examples are:
/// `http://acme.com` and `https://acme.com/sales:8080`. Cloud Tasks will
/// encode some characters for safety and compatibility. The maximum allowed
/// URL length is 2083 characters after encoding. The `Location` header
/// response from a redirect response [`300` - `399`] may be followed. The
/// redirect is not counted as a separate attempt.
core.String url;
HttpRequest();
HttpRequest.fromJson(core.Map _json) {
if (_json.containsKey("body")) {
body = _json["body"];
}
if (_json.containsKey("headers")) {
headers = (_json["headers"] as core.Map).cast<core.String, core.String>();
}
if (_json.containsKey("httpMethod")) {
httpMethod = _json["httpMethod"];
}
if (_json.containsKey("oauthToken")) {
oauthToken = new OAuthToken.fromJson(_json["oauthToken"]);
}
if (_json.containsKey("oidcToken")) {
oidcToken = new OidcToken.fromJson(_json["oidcToken"]);
}
if (_json.containsKey("url")) {
url = _json["url"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (body != null) {
_json["body"] = body;
}
if (headers != null) {
_json["headers"] = headers;
}
if (httpMethod != null) {
_json["httpMethod"] = httpMethod;
}
if (oauthToken != null) {
_json["oauthToken"] = (oauthToken).toJson();
}
if (oidcToken != null) {
_json["oidcToken"] = (oidcToken).toJson();
}
if (url != null) {
_json["url"] = url;
}
return _json;
}
}
/// The response message for Locations.ListLocations.
class ListLocationsResponse {
/// A list of locations that matches the specified filter in the request.
core.List<Location> locations;
/// The standard List next-page token.
core.String nextPageToken;
ListLocationsResponse();
ListLocationsResponse.fromJson(core.Map _json) {
if (_json.containsKey("locations")) {
locations = (_json["locations"] as core.List)
.map<Location>((value) => new Location.fromJson(value))
.toList();
}
if (_json.containsKey("nextPageToken")) {
nextPageToken = _json["nextPageToken"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (locations != null) {
_json["locations"] = locations.map((value) => (value).toJson()).toList();
}
if (nextPageToken != null) {
_json["nextPageToken"] = nextPageToken;
}
return _json;
}
}
/// Response message for ListQueues.
class ListQueuesResponse {
/// A token to retrieve next page of results. To return the next page of
/// results, call ListQueues with this value as the page_token. If the
/// next_page_token is empty, there are no more results. The page token is
/// valid for only 2 hours.
core.String nextPageToken;
/// The list of queues.
core.List<Queue> queues;
ListQueuesResponse();
ListQueuesResponse.fromJson(core.Map _json) {
if (_json.containsKey("nextPageToken")) {
nextPageToken = _json["nextPageToken"];
}
if (_json.containsKey("queues")) {
queues = (_json["queues"] as core.List)
.map<Queue>((value) => new Queue.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 (queues != null) {
_json["queues"] = queues.map((value) => (value).toJson()).toList();
}
return _json;
}
}
/// Response message for listing tasks using ListTasks.
class ListTasksResponse {
/// A token to retrieve next page of results. To return the next page of
/// results, call ListTasks with this value as the page_token. If the
/// next_page_token is empty, there are no more results.
core.String nextPageToken;
/// The list of tasks.
core.List<Task> tasks;
ListTasksResponse();
ListTasksResponse.fromJson(core.Map _json) {
if (_json.containsKey("nextPageToken")) {
nextPageToken = _json["nextPageToken"];
}
if (_json.containsKey("tasks")) {
tasks = (_json["tasks"] as core.List)
.map<Task>((value) => new Task.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 (tasks != null) {
_json["tasks"] = tasks.map((value) => (value).toJson()).toList();
}
return _json;
}
}
/// A resource that represents Google Cloud Platform location.
class Location {
/// The friendly name for this location, typically a nearby city name. For
/// example, "Tokyo".
core.String displayName;
/// Cross-service attributes for the location. For example
/// {"cloud.googleapis.com/region": "us-east1"}
core.Map<core.String, core.String> labels;
/// The canonical id for this location. For example: `"us-east1"`.
core.String locationId;
/// Service-specific metadata. For example the available capacity at the given
/// location.
///
/// 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;
/// Resource name for the location, which may vary between implementations.
/// For example: `"projects/example-project/locations/us-east1"`
core.String name;
Location();
Location.fromJson(core.Map _json) {
if (_json.containsKey("displayName")) {
displayName = _json["displayName"];
}
if (_json.containsKey("labels")) {
labels = (_json["labels"] as core.Map).cast<core.String, core.String>();
}
if (_json.containsKey("locationId")) {
locationId = _json["locationId"];
}
if (_json.containsKey("metadata")) {
metadata =
(_json["metadata"] as core.Map).cast<core.String, core.Object>();
}
if (_json.containsKey("name")) {
name = _json["name"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (displayName != null) {
_json["displayName"] = displayName;
}
if (labels != null) {
_json["labels"] = labels;
}
if (locationId != null) {
_json["locationId"] = locationId;
}
if (metadata != null) {
_json["metadata"] = metadata;
}
if (name != null) {
_json["name"] = name;
}
return _json;
}
}
/// Contains information needed for generating an [OAuth
/// token](https://developers.google.com/identity/protocols/OAuth2). This type
/// of authorization should generally only be used when calling Google APIs
/// hosted on *.googleapis.com.
class OAuthToken {
/// OAuth scope to be used for generating OAuth access token. If not
/// specified, "https://www.googleapis.com/auth/cloud-platform" will be used.
core.String scope;
/// [Service account
/// email](https://cloud.google.com/iam/docs/service-accounts) to be used for
/// generating OAuth token. The service account must be within the same
/// project as the queue. The caller must have iam.serviceAccounts.actAs
/// permission for the service account.
core.String serviceAccountEmail;
OAuthToken();
OAuthToken.fromJson(core.Map _json) {
if (_json.containsKey("scope")) {
scope = _json["scope"];
}
if (_json.containsKey("serviceAccountEmail")) {
serviceAccountEmail = _json["serviceAccountEmail"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (scope != null) {
_json["scope"] = scope;
}
if (serviceAccountEmail != null) {
_json["serviceAccountEmail"] = serviceAccountEmail;
}
return _json;
}
}
/// Contains information needed for generating an [OpenID Connect
/// token](https://developers.google.com/identity/protocols/OpenIDConnect). This
/// type of authorization can be used for many scenarios, including calling
/// Cloud Run, or endpoints where you intend to validate the token yourself.
class OidcToken {
/// Audience to be used when generating OIDC token. If not specified, the URI
/// specified in target will be used.
core.String audience;
/// [Service account
/// email](https://cloud.google.com/iam/docs/service-accounts) to be used for
/// generating OIDC token. The service account must be within the same project
/// as the queue. The caller must have iam.serviceAccounts.actAs permission
/// for the service account.
core.String serviceAccountEmail;
OidcToken();
OidcToken.fromJson(core.Map _json) {
if (_json.containsKey("audience")) {
audience = _json["audience"];
}
if (_json.containsKey("serviceAccountEmail")) {
serviceAccountEmail = _json["serviceAccountEmail"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (audience != null) {
_json["audience"] = audience;
}
if (serviceAccountEmail != null) {
_json["serviceAccountEmail"] = serviceAccountEmail;
}
return _json;
}
}
/// Request message for PauseQueue.
class PauseQueueRequest {
PauseQueueRequest();
PauseQueueRequest.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 Identity and Access Management (IAM) policy, which specifies access
/// controls for Google Cloud resources. A `Policy` is a collection of
/// `bindings`. A `binding` binds one or more `members` to a single `role`.
/// Members can be user accounts, service accounts, Google groups, and domains
/// (such as G Suite). A `role` is a named list of permissions; each `role` can
/// be an IAM predefined role or a user-created custom role. For some types of
/// Google Cloud resources, a `binding` can also specify a `condition`, which is
/// a logical expression that allows access to a resource only if the expression
/// evaluates to `true`. A condition can add constraints based on attributes of
/// the request, the resource, or both. To learn which resources support
/// conditions in their IAM policies, see the [IAM
/// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
/// **JSON example:** { "bindings": [ { "role":
/// "roles/resourcemanager.organizationAdmin", "members": [
/// "user:mike@example.com", "group:admins@example.com", "domain:google.com",
/// "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role":
/// "roles/resourcemanager.organizationViewer", "members": [
/// "user:eve@example.com" ], "condition": { "title": "expirable access",
/// "description": "Does not grant access after Sep 2020", "expression":
/// "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag":
/// "BwWWja0YfJA=", "version": 3 } **YAML example:** bindings: - members: -
/// user:mike@example.com - group:admins@example.com - domain:google.com -
/// serviceAccount:my-project-id@appspot.gserviceaccount.com role:
/// roles/resourcemanager.organizationAdmin - members: - user:eve@example.com
/// role: roles/resourcemanager.organizationViewer condition: title: expirable
/// access description: Does not grant access after Sep 2020 expression:
/// request.time < timestamp('2020-10-01T00:00:00.000Z') - etag: BwWWja0YfJA= -
/// version: 3 For a description of IAM and its features, see the [IAM
/// documentation](https://cloud.google.com/iam/docs/).
class Policy {
/// Associates a list of `members` to a `role`. Optionally, may specify a
/// `condition` that determines how and when the `bindings` are applied. Each
/// of the `bindings` must contain at least one member.
core.List<Binding> bindings;
/// `etag` is used for optimistic concurrency control as a way to help prevent
/// simultaneous updates of a policy from overwriting each other. It is
/// strongly suggested that systems make use of the `etag` in the
/// read-modify-write cycle to perform policy updates in order to avoid race
/// conditions: An `etag` is returned in the response to `getIamPolicy`, and
/// systems are expected to put that etag in the request to `setIamPolicy` to
/// ensure that their change will be applied to the same version of the
/// policy. **Important:** If you use IAM Conditions, you must include the
/// `etag` field whenever you call `setIamPolicy`. If you omit this field,
/// then IAM allows you to overwrite a version `3` policy with a version `1`
/// policy, and all of the conditions in the version `3` policy are lost.
core.String etag;
core.List<core.int> get etagAsBytes {
return convert.base64.decode(etag);
}
set etagAsBytes(core.List<core.int> _bytes) {
etag =
convert.base64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
}
/// Specifies the format of the policy. Valid values are `0`, `1`, and `3`.
/// Requests that specify an invalid value are rejected. Any operation that
/// affects conditional role bindings must specify version `3`. This
/// requirement applies to the following operations: * Getting a policy that
/// includes a conditional role binding * Adding a conditional role binding to
/// a policy * Changing a conditional role binding in a policy * Removing any
/// role binding, with or without a condition, from a policy that includes
/// conditions **Important:** If you use IAM Conditions, you must include the
/// `etag` field whenever you call `setIamPolicy`. If you omit this field,
/// then IAM allows you to overwrite a version `3` policy with a version `1`
/// policy, and all of the conditions in the version `3` policy are lost. If a
/// policy does not include any conditions, operations on that policy may
/// specify any valid version or leave the field unset. To learn which
/// resources support conditions in their IAM policies, see the [IAM
/// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
core.int version;
Policy();
Policy.fromJson(core.Map _json) {
if (_json.containsKey("bindings")) {
bindings = (_json["bindings"] as core.List)
.map<Binding>((value) => new Binding.fromJson(value))
.toList();
}
if (_json.containsKey("etag")) {
etag = _json["etag"];
}
if (_json.containsKey("version")) {
version = _json["version"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (bindings != null) {
_json["bindings"] = bindings.map((value) => (value).toJson()).toList();
}
if (etag != null) {
_json["etag"] = etag;
}
if (version != null) {
_json["version"] = version;
}
return _json;
}
}
/// Request message for PurgeQueue.
class PurgeQueueRequest {
PurgeQueueRequest();
PurgeQueueRequest.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 queue is a container of related tasks. Queues are configured to manage how
/// those tasks are dispatched. Configurable properties include rate limits,
/// retry options, queue types, and others.
class Queue {
/// Overrides for task-level app_engine_routing. These settings apply only to
/// App Engine tasks in this queue. Http tasks are not affected. If set,
/// `app_engine_routing_override` is used for all App Engine tasks in the
/// queue, no matter what the setting is for the task-level
/// app_engine_routing.
AppEngineRouting appEngineRoutingOverride;
/// Caller-specified and required in CreateQueue, after which it becomes
/// output only. The queue name. The queue name must have the following
/// format: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID` *
/// `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]), hyphens (-),
/// colons (:), or periods (.). For more information, see [Identifying
/// projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)
/// * `LOCATION_ID` is the canonical ID for the queue's location. The list of
/// available locations can be obtained by calling ListLocations. For more
/// information, see https://cloud.google.com/about/locations/. * `QUEUE_ID`
/// can contain letters ([A-Za-z]), numbers ([0-9]), or hyphens (-). The
/// maximum length is 100 characters.
core.String name;
/// Output only. The last time this queue was purged. All tasks that were
/// created before this time were purged. A queue can be purged using
/// PurgeQueue, the [App Engine Task Queue SDK, or the Cloud
/// Console](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/deleting-tasks-and-queues#purging_all_tasks_from_a_queue).
/// Purge time will be truncated to the nearest microsecond. Purge time will
/// be unset if the queue has never been purged.
core.String purgeTime;
/// Rate limits for task dispatches. rate_limits and retry_config are related
/// because they both control task attempts. However they control task
/// attempts in different ways: * rate_limits controls the total rate of
/// dispatches from a queue (i.e. all traffic dispatched from the queue,
/// regardless of whether the dispatch is from a first attempt or a retry). *
/// retry_config controls what happens to particular a task after its first
/// attempt fails. That is, retry_config controls task retries (the second
/// attempt, third attempt, etc). The queue's actual dispatch rate is the
/// result of: * Number of tasks in the queue * User-specified throttling:
/// rate_limits, retry_config, and the queue's state. * System throttling due
/// to `429` (Too Many Requests) or `503` (Service Unavailable) responses from
/// the worker, high error rates, or to smooth sudden large traffic spikes.
RateLimits rateLimits;
/// Settings that determine the retry behavior. * For tasks created using
/// Cloud Tasks: the queue-level retry settings apply to all tasks in the
/// queue that were created using Cloud Tasks. Retry settings cannot be set on
/// individual tasks. * For tasks created using the App Engine SDK: the
/// queue-level retry settings apply to all tasks in the queue which do not
/// have retry settings explicitly set on the task and were created by the App
/// Engine SDK. See [App Engine
/// documentation](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/retrying-tasks).
RetryConfig retryConfig;
/// Configuration options for writing logs to [Stackdriver
/// Logging](https://cloud.google.com/logging/docs/). If this field is unset,
/// then no logs are written.
StackdriverLoggingConfig stackdriverLoggingConfig;
/// Output only. The state of the queue. `state` can only be changed by called
/// PauseQueue, ResumeQueue, or uploading
/// [queue.yaml/xml](https://cloud.google.com/appengine/docs/python/config/queueref).
/// UpdateQueue cannot be used to change `state`.
/// Possible string values are:
/// - "STATE_UNSPECIFIED" : Unspecified state.
/// - "RUNNING" : The queue is running. Tasks can be dispatched. If the queue
/// was created using Cloud Tasks and the queue has had no activity (method
/// calls or task dispatches) for 30 days, the queue may take a few minutes to
/// re-activate. Some method calls may return NOT_FOUND and tasks may not be
/// dispatched for a few minutes until the queue has been re-activated.
/// - "PAUSED" : Tasks are paused by the user. If the queue is paused then
/// Cloud Tasks will stop delivering tasks from it, but more tasks can still
/// be added to it by the user.
/// - "DISABLED" : The queue is disabled. A queue becomes `DISABLED` when
/// [queue.yaml](https://cloud.google.com/appengine/docs/python/config/queueref)
/// or
/// [queue.xml](https://cloud.google.com/appengine/docs/standard/java/config/queueref)
/// is uploaded which does not contain the queue. You cannot directly disable
/// a queue. When a queue is disabled, tasks can still be added to a queue but
/// the tasks are not dispatched. To permanently delete this queue and all of
/// its tasks, call DeleteQueue.
core.String state;
Queue();
Queue.fromJson(core.Map _json) {
if (_json.containsKey("appEngineRoutingOverride")) {
appEngineRoutingOverride =
new AppEngineRouting.fromJson(_json["appEngineRoutingOverride"]);
}
if (_json.containsKey("name")) {
name = _json["name"];
}
if (_json.containsKey("purgeTime")) {
purgeTime = _json["purgeTime"];
}
if (_json.containsKey("rateLimits")) {
rateLimits = new RateLimits.fromJson(_json["rateLimits"]);
}
if (_json.containsKey("retryConfig")) {
retryConfig = new RetryConfig.fromJson(_json["retryConfig"]);
}
if (_json.containsKey("stackdriverLoggingConfig")) {
stackdriverLoggingConfig = new StackdriverLoggingConfig.fromJson(
_json["stackdriverLoggingConfig"]);
}
if (_json.containsKey("state")) {
state = _json["state"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (appEngineRoutingOverride != null) {
_json["appEngineRoutingOverride"] = (appEngineRoutingOverride).toJson();
}
if (name != null) {
_json["name"] = name;
}
if (purgeTime != null) {
_json["purgeTime"] = purgeTime;
}
if (rateLimits != null) {
_json["rateLimits"] = (rateLimits).toJson();
}
if (retryConfig != null) {
_json["retryConfig"] = (retryConfig).toJson();
}
if (stackdriverLoggingConfig != null) {
_json["stackdriverLoggingConfig"] = (stackdriverLoggingConfig).toJson();
}
if (state != null) {
_json["state"] = state;
}
return _json;
}
}
/// Rate limits. This message determines the maximum rate that tasks can be
/// dispatched by a queue, regardless of whether the dispatch is a first task
/// attempt or a retry. Note: The debugging command, RunTask, will run a task
/// even if the queue has reached its RateLimits.
class RateLimits {
/// Output only. The max burst size. Max burst size limits how fast tasks in
/// queue are processed when many tasks are in the queue and the rate is high.
/// This field allows the queue to have a high rate so processing starts
/// shortly after a task is enqueued, but still limits resource usage when
/// many tasks are enqueued in a short period of time. The [token
/// bucket](https://wikipedia.org/wiki/Token_Bucket) algorithm is used to
/// control the rate of task dispatches. Each queue has a token bucket that
/// holds tokens, up to the maximum specified by `max_burst_size`. Each time a
/// task is dispatched, a token is removed from the bucket. Tasks will be
/// dispatched until the queue's bucket runs out of tokens. The bucket will be
/// continuously refilled with new tokens based on max_dispatches_per_second.
/// Cloud Tasks will pick the value of `max_burst_size` based on the value of
/// max_dispatches_per_second. For queues that were created or updated using
/// `queue.yaml/xml`, `max_burst_size` is equal to
/// [bucket_size](https://cloud.google.com/appengine/docs/standard/python/config/queueref#bucket_size).
/// Since `max_burst_size` is output only, if UpdateQueue is called on a queue
/// created by `queue.yaml/xml`, `max_burst_size` will be reset based on the
/// value of max_dispatches_per_second, regardless of whether
/// max_dispatches_per_second is updated.
core.int maxBurstSize;
/// The maximum number of concurrent tasks that Cloud Tasks allows to be
/// dispatched for this queue. After this threshold has been reached, Cloud
/// Tasks stops dispatching tasks until the number of concurrent requests
/// decreases. If unspecified when the queue is created, Cloud Tasks will pick
/// the default. The maximum allowed value is 5,000. This field has the same
/// meaning as [max_concurrent_requests in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#max_concurrent_requests).
core.int maxConcurrentDispatches;
/// The maximum rate at which tasks are dispatched from this queue. If
/// unspecified when the queue is created, Cloud Tasks will pick the default.
/// * The maximum allowed value is 500. This field has the same meaning as
/// [rate in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#rate).
core.double maxDispatchesPerSecond;
RateLimits();
RateLimits.fromJson(core.Map _json) {
if (_json.containsKey("maxBurstSize")) {
maxBurstSize = _json["maxBurstSize"];
}
if (_json.containsKey("maxConcurrentDispatches")) {
maxConcurrentDispatches = _json["maxConcurrentDispatches"];
}
if (_json.containsKey("maxDispatchesPerSecond")) {
maxDispatchesPerSecond = _json["maxDispatchesPerSecond"].toDouble();
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (maxBurstSize != null) {
_json["maxBurstSize"] = maxBurstSize;
}
if (maxConcurrentDispatches != null) {
_json["maxConcurrentDispatches"] = maxConcurrentDispatches;
}
if (maxDispatchesPerSecond != null) {
_json["maxDispatchesPerSecond"] = maxDispatchesPerSecond;
}
return _json;
}
}
/// Request message for ResumeQueue.
class ResumeQueueRequest {
ResumeQueueRequest();
ResumeQueueRequest.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;
}
}
/// Retry config. These settings determine when a failed task attempt is
/// retried.
class RetryConfig {
/// Number of attempts per task. Cloud Tasks will attempt the task
/// `max_attempts` times (that is, if the first attempt fails, then there will
/// be `max_attempts - 1` retries). Must be >= -1. If unspecified when the
/// queue is created, Cloud Tasks will pick the default. -1 indicates
/// unlimited attempts. This field has the same meaning as [task_retry_limit
/// in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
core.int maxAttempts;
/// A task will be scheduled for retry between min_backoff and max_backoff
/// duration after it fails, if the queue's RetryConfig specifies that the
/// task should be retried. If unspecified when the queue is created, Cloud
/// Tasks will pick the default. `max_backoff` will be truncated to the
/// nearest second. This field has the same meaning as [max_backoff_seconds in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
core.String maxBackoff;
/// The time between retries will double `max_doublings` times. A task's retry
/// interval starts at min_backoff, then doubles `max_doublings` times, then
/// increases linearly, and finally retries at intervals of max_backoff up to
/// max_attempts times. For example, if min_backoff is 10s, max_backoff is
/// 300s, and `max_doublings` is 3, then the a task will first be retried in
/// 10s. The retry interval will double three times, and then increase
/// linearly by 2^3 * 10s. Finally, the task will retry at intervals of
/// max_backoff until the task has been attempted max_attempts times. Thus,
/// the requests will retry at 10s, 20s, 40s, 80s, 160s, 240s, 300s, 300s,
/// .... If unspecified when the queue is created, Cloud Tasks will pick the
/// default. This field has the same meaning as [max_doublings in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
core.int maxDoublings;
/// If positive, `max_retry_duration` specifies the time limit for retrying a
/// failed task, measured from when the task was first attempted. Once
/// `max_retry_duration` time has passed *and* the task has been attempted
/// max_attempts times, no further attempts will be made and the task will be
/// deleted. If zero, then the task age is unlimited. If unspecified when the
/// queue is created, Cloud Tasks will pick the default. `max_retry_duration`
/// will be truncated to the nearest second. This field has the same meaning
/// as [task_age_limit in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
core.String maxRetryDuration;
/// A task will be scheduled for retry between min_backoff and max_backoff
/// duration after it fails, if the queue's RetryConfig specifies that the
/// task should be retried. If unspecified when the queue is created, Cloud
/// Tasks will pick the default. `min_backoff` will be truncated to the
/// nearest second. This field has the same meaning as [min_backoff_seconds in
/// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
core.String minBackoff;
RetryConfig();
RetryConfig.fromJson(core.Map _json) {
if (_json.containsKey("maxAttempts")) {
maxAttempts = _json["maxAttempts"];
}
if (_json.containsKey("maxBackoff")) {
maxBackoff = _json["maxBackoff"];
}
if (_json.containsKey("maxDoublings")) {
maxDoublings = _json["maxDoublings"];
}
if (_json.containsKey("maxRetryDuration")) {
maxRetryDuration = _json["maxRetryDuration"];
}
if (_json.containsKey("minBackoff")) {
minBackoff = _json["minBackoff"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (maxAttempts != null) {
_json["maxAttempts"] = maxAttempts;
}
if (maxBackoff != null) {
_json["maxBackoff"] = maxBackoff;
}
if (maxDoublings != null) {
_json["maxDoublings"] = maxDoublings;
}
if (maxRetryDuration != null) {
_json["maxRetryDuration"] = maxRetryDuration;
}
if (minBackoff != null) {
_json["minBackoff"] = minBackoff;
}
return _json;
}
}
/// Request message for forcing a task to run now using RunTask.
class RunTaskRequest {
/// The response_view specifies which subset of the Task will be returned. By
/// default response_view is BASIC; not all information is retrieved by
/// default because some data, such as payloads, might be desirable to return
/// only when needed because of its large size or because of the sensitivity
/// of data that it contains. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Task resource.
/// Possible string values are:
/// - "VIEW_UNSPECIFIED" : Unspecified. Defaults to BASIC.
/// - "BASIC" : The basic view omits fields which can be large or can contain
/// sensitive data. This view does not include the body in
/// AppEngineHttpRequest. Bodies are desirable to return only when needed,
/// because they can be large and because of the sensitivity of the data that
/// you choose to store in it.
/// - "FULL" : All information is returned. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Queue resource.
core.String responseView;
RunTaskRequest();
RunTaskRequest.fromJson(core.Map _json) {
if (_json.containsKey("responseView")) {
responseView = _json["responseView"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (responseView != null) {
_json["responseView"] = responseView;
}
return _json;
}
}
/// Request message for `SetIamPolicy` method.
class SetIamPolicyRequest {
/// REQUIRED: The complete policy to be applied to the `resource`. The size of
/// the policy is limited to a few 10s of KB. An empty policy is a valid
/// policy but certain Cloud Platform services (such as Projects) might reject
/// them.
Policy policy;
SetIamPolicyRequest();
SetIamPolicyRequest.fromJson(core.Map _json) {
if (_json.containsKey("policy")) {
policy = new Policy.fromJson(_json["policy"]);
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (policy != null) {
_json["policy"] = (policy).toJson();
}
return _json;
}
}
/// Configuration options for writing logs to [Stackdriver
/// Logging](https://cloud.google.com/logging/docs/).
class StackdriverLoggingConfig {
/// Specifies the fraction of operations to write to [Stackdriver
/// Logging](https://cloud.google.com/logging/docs/). This field may contain
/// any value between 0.0 and 1.0, inclusive. 0.0 is the default and means
/// that no operations are logged.
core.double samplingRatio;
StackdriverLoggingConfig();
StackdriverLoggingConfig.fromJson(core.Map _json) {
if (_json.containsKey("samplingRatio")) {
samplingRatio = _json["samplingRatio"].toDouble();
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (samplingRatio != null) {
_json["samplingRatio"] = samplingRatio;
}
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;
}
}
/// A unit of scheduled work.
class Task {
/// HTTP request that is sent to the App Engine app handler. An App Engine
/// task is a task that has AppEngineHttpRequest set.
AppEngineHttpRequest appEngineHttpRequest;
/// Output only. The time that the task was created. `create_time` will be
/// truncated to the nearest second.
core.String createTime;
/// Output only. The number of attempts dispatched. This count includes
/// attempts which have been dispatched but haven't received a response.
core.int dispatchCount;
/// The deadline for requests sent to the worker. If the worker does not
/// respond by this deadline then the request is cancelled and the attempt is
/// marked as a `DEADLINE_EXCEEDED` failure. Cloud Tasks will retry the task
/// according to the RetryConfig. Note that when the request is cancelled,
/// Cloud Tasks will stop listening for the response, but whether the worker
/// stops processing depends on the worker. For example, if the worker is
/// stuck, it may not react to cancelled requests. The default and maximum
/// values depend on the type of request: * For HTTP tasks, the default is 10
/// minutes. The deadline must be in the interval [15 seconds, 30 minutes]. *
/// For App Engine tasks, 0 indicates that the request has the default
/// deadline. The default deadline depends on the [scaling
/// type](https://cloud.google.com/appengine/docs/standard/go/how-instances-are-managed#instance_scaling)
/// of the service: 10 minutes for standard apps with automatic scaling, 24
/// hours for standard apps with manual and basic scaling, and 60 minutes for
/// flex apps. If the request deadline is set, it must be in the interval [15
/// seconds, 24 hours 15 seconds]. Regardless of the task's
/// `dispatch_deadline`, the app handler will not run for longer than than the
/// service's timeout. We recommend setting the `dispatch_deadline` to at most
/// a few seconds more than the app handler's timeout. For more information
/// see
/// [Timeouts](https://cloud.google.com/tasks/docs/creating-appengine-handlers#timeouts).
/// `dispatch_deadline` will be truncated to the nearest millisecond. The
/// deadline is an approximate deadline.
core.String dispatchDeadline;
/// Output only. The status of the task's first attempt. Only dispatch_time
/// will be set. The other Attempt information is not retained by Cloud Tasks.
Attempt firstAttempt;
/// HTTP request that is sent to the worker. An HTTP task is a task that has
/// HttpRequest set.
HttpRequest httpRequest;
/// Output only. The status of the task's last attempt.
Attempt lastAttempt;
/// Optionally caller-specified in CreateTask. The task name. The task name
/// must have the following format:
/// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
/// * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]), hyphens
/// (-), colons (:), or periods (.). For more information, see [Identifying
/// projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)
/// * `LOCATION_ID` is the canonical ID for the task's location. The list of
/// available locations can be obtained by calling ListLocations. For more
/// information, see https://cloud.google.com/about/locations/. * `QUEUE_ID`
/// can contain letters ([A-Za-z]), numbers ([0-9]), or hyphens (-). The
/// maximum length is 100 characters. * `TASK_ID` can contain only letters
/// ([A-Za-z]), numbers ([0-9]), hyphens (-), or underscores (_). The maximum
/// length is 500 characters.
core.String name;
/// Output only. The number of attempts which have received a response.
core.int responseCount;
/// The time when the task is scheduled to be attempted or retried.
/// `schedule_time` will be truncated to the nearest microsecond.
core.String scheduleTime;
/// Output only. The view specifies which subset of the Task has been
/// returned.
/// Possible string values are:
/// - "VIEW_UNSPECIFIED" : Unspecified. Defaults to BASIC.
/// - "BASIC" : The basic view omits fields which can be large or can contain
/// sensitive data. This view does not include the body in
/// AppEngineHttpRequest. Bodies are desirable to return only when needed,
/// because they can be large and because of the sensitivity of the data that
/// you choose to store in it.
/// - "FULL" : All information is returned. Authorization for FULL requires
/// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
/// permission on the Queue resource.
core.String view;
Task();
Task.fromJson(core.Map _json) {
if (_json.containsKey("appEngineHttpRequest")) {
appEngineHttpRequest =
new AppEngineHttpRequest.fromJson(_json["appEngineHttpRequest"]);
}
if (_json.containsKey("createTime")) {
createTime = _json["createTime"];
}
if (_json.containsKey("dispatchCount")) {
dispatchCount = _json["dispatchCount"];
}
if (_json.containsKey("dispatchDeadline")) {
dispatchDeadline = _json["dispatchDeadline"];
}
if (_json.containsKey("firstAttempt")) {
firstAttempt = new Attempt.fromJson(_json["firstAttempt"]);
}
if (_json.containsKey("httpRequest")) {
httpRequest = new HttpRequest.fromJson(_json["httpRequest"]);
}
if (_json.containsKey("lastAttempt")) {
lastAttempt = new Attempt.fromJson(_json["lastAttempt"]);
}
if (_json.containsKey("name")) {
name = _json["name"];
}
if (_json.containsKey("responseCount")) {
responseCount = _json["responseCount"];
}
if (_json.containsKey("scheduleTime")) {
scheduleTime = _json["scheduleTime"];
}
if (_json.containsKey("view")) {
view = _json["view"];
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (appEngineHttpRequest != null) {
_json["appEngineHttpRequest"] = (appEngineHttpRequest).toJson();
}
if (createTime != null) {
_json["createTime"] = createTime;
}
if (dispatchCount != null) {
_json["dispatchCount"] = dispatchCount;
}
if (dispatchDeadline != null) {
_json["dispatchDeadline"] = dispatchDeadline;
}
if (firstAttempt != null) {
_json["firstAttempt"] = (firstAttempt).toJson();
}
if (httpRequest != null) {
_json["httpRequest"] = (httpRequest).toJson();
}
if (lastAttempt != null) {
_json["lastAttempt"] = (lastAttempt).toJson();
}
if (name != null) {
_json["name"] = name;
}
if (responseCount != null) {
_json["responseCount"] = responseCount;
}
if (scheduleTime != null) {
_json["scheduleTime"] = scheduleTime;
}
if (view != null) {
_json["view"] = view;
}
return _json;
}
}
/// Request message for `TestIamPermissions` method.
class TestIamPermissionsRequest {
/// The set of permissions to check for the `resource`. Permissions with
/// wildcards (such as '*' or 'storage.*') are not allowed. For more
/// information see [IAM
/// Overview](https://cloud.google.com/iam/docs/overview#permissions).
core.List<core.String> permissions;
TestIamPermissionsRequest();
TestIamPermissionsRequest.fromJson(core.Map _json) {
if (_json.containsKey("permissions")) {
permissions = (_json["permissions"] as core.List).cast<core.String>();
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (permissions != null) {
_json["permissions"] = permissions;
}
return _json;
}
}
/// Response message for `TestIamPermissions` method.
class TestIamPermissionsResponse {
/// A subset of `TestPermissionsRequest.permissions` that the caller is
/// allowed.
core.List<core.String> permissions;
TestIamPermissionsResponse();
TestIamPermissionsResponse.fromJson(core.Map _json) {
if (_json.containsKey("permissions")) {
permissions = (_json["permissions"] as core.List).cast<core.String>();
}
}
core.Map<core.String, core.Object> toJson() {
final core.Map<core.String, core.Object> _json =
new core.Map<core.String, core.Object>();
if (permissions != null) {
_json["permissions"] = permissions;
}
return _json;
}
}