generated/googleapis_beta/lib/lifesciences/v2beta.dart

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

// ignore_for_file: unused_import, unnecessary_cast

library googleapis_beta.lifesciences.v2beta;

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 lifesciences/v2beta';

/// Cloud Life Sciences is a suite of services and tools for managing,
/// processing, and transforming life sciences data.
class LifesciencesApi {
  /// 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);

  LifesciencesApi(http.Client client,
      {core.String rootUrl = "https://lifesciences.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;

  ProjectsLocationsOperationsResourceApi get operations =>
      new ProjectsLocationsOperationsResourceApi(_requester);
  ProjectsLocationsPipelinesResourceApi get pipelines =>
      new ProjectsLocationsPipelinesResourceApi(_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 = 'v2beta/' + 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/[^/]+$".
  ///
  /// [filter] - The standard list filter.
  ///
  /// [pageToken] - The standard list page token.
  ///
  /// [pageSize] - The standard list page size.
  ///
  /// [$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.String filter,
      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 (name == null) {
      throw new core.ArgumentError("Parameter name is required.");
    }
    if (filter != null) {
      _queryParams["filter"] = [filter];
    }
    if (pageToken != null) {
      _queryParams["pageToken"] = [pageToken];
    }
    if (pageSize != null) {
      _queryParams["pageSize"] = ["${pageSize}"];
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'v2beta/' +
        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 ProjectsLocationsOperationsResourceApi {
  final commons.ApiRequester _requester;

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

  /// Starts asynchronous cancellation on a long-running operation.
  /// The server makes a best effort to cancel the operation, but success is not
  /// guaranteed. Clients may use Operations.GetOperation
  /// or Operations.ListOperations
  /// to check whether the cancellation succeeded or the operation completed
  /// despite cancellation.
  /// Authorization requires the following [Google
  /// IAM](https://cloud.google.com/iam) permission&#58;
  ///
  /// * `lifesciences.operations.cancel`
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [name] - The name of the operation resource to be cancelled.
  /// Value must have pattern
  /// "^projects/[^/]+/locations/[^/]+/operations/[^/]+$".
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Empty].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Empty> cancel(CancelOperationRequest request, core.String name,
      {core.String $fields}) {
    var _url;
    var _queryParams = new core.Map<core.String, core.List<core.String>>();
    var _uploadMedia;
    var _uploadOptions;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body;

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

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

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

  /// Gets the latest state of a long-running operation.
  /// Clients can use this method to poll the operation result at intervals as
  /// recommended by the API service.
  /// Authorization requires the following [Google
  /// IAM](https://cloud.google.com/iam) permission&#58;
  ///
  /// * `lifesciences.operations.get`
  ///
  /// Request parameters:
  ///
  /// [name] - The name of the operation resource.
  /// Value must have pattern
  /// "^projects/[^/]+/locations/[^/]+/operations/[^/]+$".
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Operation].
  ///
  /// 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<Operation> 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 = 'v2beta/' + 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 Operation.fromJson(data));
  }

  /// Lists operations that match the specified filter in the request.
  /// Authorization requires the following [Google
  /// IAM](https://cloud.google.com/iam) permission&#58;
  ///
  /// * `lifesciences.operations.list`
  ///
  /// Request parameters:
  ///
  /// [name] - The name of the operation's parent resource.
  /// Value must have pattern "^projects/[^/]+/locations/[^/]+$".
  ///
  /// [pageToken] - The standard list page token.
  ///
  /// [pageSize] - The maximum number of results to return. The maximum value is
  /// 256.
  ///
  /// [filter] - A string for filtering Operations.
  /// The following filter fields are supported&#58;
  ///
  /// * createTime&#58; The time this job was created
  /// * events&#58; The set of event (names) that have occurred while running
  ///   the pipeline.  The &#58; operator can be used to determine if a
  ///   particular event has occurred.
  /// * error&#58; If the pipeline is running, this value is NULL.  Once the
  ///   pipeline finishes, the value is the standard Google error code.
  /// * labels.key or labels."key with space" where key is a label key.
  /// * done&#58; If the pipeline is running, this value is false. Once the
  ///   pipeline finishes, the value is true.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListOperationsResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListOperationsResponse> list(core.String name,
      {core.String pageToken,
      core.int pageSize,
      core.String filter,
      core.String $fields}) {
    var _url;
    var _queryParams = new core.Map<core.String, core.List<core.String>>();
    var _uploadMedia;
    var _uploadOptions;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body;

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

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

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

class ProjectsLocationsPipelinesResourceApi {
  final commons.ApiRequester _requester;

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

  /// Runs a pipeline.  The returned Operation's metadata field will contain a
  /// google.cloud.lifesciences.v2beta.Metadata object describing the status
  /// of the pipeline execution. The
  /// response field will contain a
  /// google.cloud.lifesciences.v2beta.RunPipelineResponse object if the
  /// pipeline completes successfully.
  ///
  /// **Note:** Before you can use this method, the *Life Sciences Service
  /// Agent*
  /// must have access to your project. This is done automatically when the
  /// Cloud Life Sciences API is first enabled, but if you delete this
  /// permission
  /// you must disable and re-enable the API to grant the Life Sciences
  /// Service Agent the required permissions.
  /// Authorization requires the following [Google
  /// IAM](https://cloud.google.com/iam/) permission:
  ///
  /// * `lifesciences.workflows.run`
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [parent] - The project and location that this request should be executed
  /// against.
  /// Value must have pattern "^projects/[^/]+/locations/[^/]+$".
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Operation].
  ///
  /// 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<Operation> run(RunPipelineRequest 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 = 'v2beta/' +
        commons.Escaper.ecapeVariableReserved('$parent') +
        '/pipelines:run';

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

/// Carries information about an accelerator that can be attached to a VM.
class Accelerator {
  /// How many accelerators of this type to attach.
  core.String count;

  /// The accelerator type string (for example, "nvidia-tesla-k80").
  ///
  /// Only NVIDIA GPU accelerators are currently supported. If an NVIDIA GPU is
  /// attached, the required runtime libraries will be made available to all
  /// containers under `/usr/local/nvidia`. The driver version to install must
  /// be specified using the NVIDIA driver version parameter on the virtual
  /// machine specification. Note that attaching a GPU increases the worker VM
  /// startup time by a few minutes.
  core.String type;

  Accelerator();

  Accelerator.fromJson(core.Map _json) {
    if (_json.containsKey("count")) {
      count = _json["count"];
    }
    if (_json.containsKey("type")) {
      type = _json["type"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (count != null) {
      _json["count"] = count;
    }
    if (type != null) {
      _json["type"] = type;
    }
    return _json;
  }
}

/// Specifies a single action that runs a Docker container.
class Action {
  /// By default, after an action fails, no further actions are run. This flag
  /// indicates that this action must be run even if the pipeline has already
  /// failed. This is useful for actions that copy output files off of the VM
  /// or for debugging. Note that no actions will be run if image prefetching
  /// fails.
  core.bool alwaysRun;

  /// If specified, overrides the `CMD` specified in the container. If the
  /// container also has an `ENTRYPOINT` the values are used as entrypoint
  /// arguments. Otherwise, they are used as a command and arguments to run
  /// inside the container.
  core.List<core.String> commands;

  /// An optional name for the container. The container hostname will be set to
  /// this name, making it useful for inter-container communication. The name
  /// must contain only upper and lowercase alphanumeric characters and hyphens
  /// and cannot start with a hyphen.
  core.String containerName;

  /// If the specified image is hosted on a private registry other than Google
  /// Container Registry, the credentials required to pull the image must be
  /// specified here as an encrypted secret.
  ///
  /// The secret must decrypt to a JSON-encoded dictionary containing both
  /// `username` and `password` keys.
  Secret credentials;

  /// All container images are typically downloaded before any actions are
  /// executed. This helps prevent typos in URIs or issues like lack of disk
  /// space from wasting large amounts of compute resources.
  ///
  /// If set, this flag prevents the worker from downloading the image until
  /// just before the action is executed.
  core.bool disableImagePrefetch;

  /// A small portion of the container's standard error stream is typically
  /// captured and returned inside the `ContainerStoppedEvent`. Setting this
  /// flag disables this functionality.
  core.bool disableStandardErrorCapture;

  /// Enable access to the FUSE device for this action. Filesystems can then
  /// be mounted into disks shared with other actions. The other actions do
  /// not need the `enable_fuse` flag to access the mounted filesystem.
  ///
  /// This has the effect of causing the container to be executed with
  /// `CAP_SYS_ADMIN` and exposes `/dev/fuse` to the container, so use it only
  /// for containers you trust.
  core.bool enableFuse;

  /// If specified, overrides the `ENTRYPOINT` specified in the container.
  core.String entrypoint;

  /// The environment to pass into the container. This environment is merged
  /// with values specified in the google.cloud.lifesciences.v2beta.Pipeline
  /// message, overwriting any duplicate values.
  ///
  /// In addition to the values passed here, a few other values are
  /// automatically injected into the environment. These cannot be hidden or
  /// overwritten.
  ///
  /// `GOOGLE_PIPELINE_FAILED` will be set to "1" if the pipeline failed
  /// because an action has exited with a non-zero status (and did not have the
  /// `IGNORE_EXIT_STATUS` flag set). This can be used to determine if
  /// additional
  /// debug or logging actions should execute.
  ///
  /// `GOOGLE_LAST_EXIT_STATUS` will be set to the exit status of the last
  /// non-background action that executed. This can be used by workflow engine
  /// authors to determine whether an individual action has succeeded or failed.
  core.Map<core.String, core.String> environment;

  /// Normally, a non-zero exit status causes the pipeline to fail. This flag
  /// allows execution of other actions to continue instead.
  core.bool ignoreExitStatus;

  /// Required. The URI to pull the container image from. Note that all images
  /// referenced
  /// by actions in the pipeline are pulled before the first action runs. If
  /// multiple actions reference the same image, it is only pulled once,
  /// ensuring that the same image is used for all actions in a single pipeline.
  ///
  /// The image URI can be either a complete host and image specification (e.g.,
  /// quay.io/biocontainers/samtools), a library and image name (e.g.,
  /// google/cloud-sdk) or a bare image name ('bash') to pull from the default
  /// library.  No schema is required in any of these cases.
  ///
  /// If the specified image is not public, the service account specified for
  /// the Virtual Machine must have access to pull the images from GCR, or
  /// appropriate credentials must be specified in the
  /// google.cloud.lifesciences.v2beta.Action.credentials field.
  core.String imageUri;

  /// Labels to associate with the action. This field is provided to assist
  /// workflow engine authors in identifying actions (for example, to indicate
  /// what sort of action they perform, such as localization or debugging).
  /// They are returned in the operation metadata, but are otherwise ignored.
  core.Map<core.String, core.String> labels;

  /// A list of mounts to make available to the action.
  ///
  /// In addition to the values specified here, every action has a special
  /// virtual disk mounted under `/google` that contains log files and other
  /// operational components.
  ///
  /// <ul>
  ///   <li><code>/google/logs</code> All logs written during the pipeline
  ///   execution.</li>
  ///   <li><code>/google/logs/output</code> The combined standard output and
  ///   standard error of all actions run as part of the pipeline
  ///   execution.</li>
  /// <li><code>/google/logs/action / * /stdout</code> The complete contents of
  ///   each individual action's standard output.</li>
  /// <li><code>/google/logs/action / * /stderr</code> The complete contents of
  ///   each individual action's standard error output.</li>
  /// </ul>
  core.List<Mount> mounts;

  /// An optional identifier for a PID namespace to run the action inside.
  /// Multiple actions should use the same string to share a namespace.  If
  /// unspecified, a separate isolated namespace is used.
  core.String pidNamespace;

  /// A map of containers to host port mappings for this container. If the
  /// container already specifies exposed ports, use the
  /// `PUBLISH_EXPOSED_PORTS` flag instead.
  ///
  /// The host port number must be less than 65536. If it is zero, an unused
  /// random port is assigned. To determine the resulting port number, consult
  /// the `ContainerStartedEvent` in the operation metadata.
  core.Map<core.String, core.int> portMappings;

  /// Exposes all ports specified by `EXPOSE` statements in the container. To
  /// discover the host side port numbers, consult the `ACTION_STARTED` event
  /// in the operation metadata.
  core.bool publishExposedPorts;

  /// This flag allows an action to continue running in the background while
  /// executing subsequent actions. This is useful to provide services to
  /// other actions (or to provide debugging support tools like SSH servers).
  core.bool runInBackground;

  /// The maximum amount of time to give the action to complete. If the action
  /// fails to complete before the timeout, it will be terminated and the exit
  /// status will be non-zero. The pipeline will continue or terminate based
  /// on the rules defined by the `ALWAYS_RUN` and `IGNORE_EXIT_STATUS` flags.
  core.String timeout;

  Action();

  Action.fromJson(core.Map _json) {
    if (_json.containsKey("alwaysRun")) {
      alwaysRun = _json["alwaysRun"];
    }
    if (_json.containsKey("commands")) {
      commands = (_json["commands"] as core.List).cast<core.String>();
    }
    if (_json.containsKey("containerName")) {
      containerName = _json["containerName"];
    }
    if (_json.containsKey("credentials")) {
      credentials = new Secret.fromJson(_json["credentials"]);
    }
    if (_json.containsKey("disableImagePrefetch")) {
      disableImagePrefetch = _json["disableImagePrefetch"];
    }
    if (_json.containsKey("disableStandardErrorCapture")) {
      disableStandardErrorCapture = _json["disableStandardErrorCapture"];
    }
    if (_json.containsKey("enableFuse")) {
      enableFuse = _json["enableFuse"];
    }
    if (_json.containsKey("entrypoint")) {
      entrypoint = _json["entrypoint"];
    }
    if (_json.containsKey("environment")) {
      environment =
          (_json["environment"] as core.Map).cast<core.String, core.String>();
    }
    if (_json.containsKey("ignoreExitStatus")) {
      ignoreExitStatus = _json["ignoreExitStatus"];
    }
    if (_json.containsKey("imageUri")) {
      imageUri = _json["imageUri"];
    }
    if (_json.containsKey("labels")) {
      labels = (_json["labels"] as core.Map).cast<core.String, core.String>();
    }
    if (_json.containsKey("mounts")) {
      mounts = (_json["mounts"] as core.List)
          .map<Mount>((value) => new Mount.fromJson(value))
          .toList();
    }
    if (_json.containsKey("pidNamespace")) {
      pidNamespace = _json["pidNamespace"];
    }
    if (_json.containsKey("portMappings")) {
      portMappings =
          (_json["portMappings"] as core.Map).cast<core.String, core.int>();
    }
    if (_json.containsKey("publishExposedPorts")) {
      publishExposedPorts = _json["publishExposedPorts"];
    }
    if (_json.containsKey("runInBackground")) {
      runInBackground = _json["runInBackground"];
    }
    if (_json.containsKey("timeout")) {
      timeout = _json["timeout"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (alwaysRun != null) {
      _json["alwaysRun"] = alwaysRun;
    }
    if (commands != null) {
      _json["commands"] = commands;
    }
    if (containerName != null) {
      _json["containerName"] = containerName;
    }
    if (credentials != null) {
      _json["credentials"] = (credentials).toJson();
    }
    if (disableImagePrefetch != null) {
      _json["disableImagePrefetch"] = disableImagePrefetch;
    }
    if (disableStandardErrorCapture != null) {
      _json["disableStandardErrorCapture"] = disableStandardErrorCapture;
    }
    if (enableFuse != null) {
      _json["enableFuse"] = enableFuse;
    }
    if (entrypoint != null) {
      _json["entrypoint"] = entrypoint;
    }
    if (environment != null) {
      _json["environment"] = environment;
    }
    if (ignoreExitStatus != null) {
      _json["ignoreExitStatus"] = ignoreExitStatus;
    }
    if (imageUri != null) {
      _json["imageUri"] = imageUri;
    }
    if (labels != null) {
      _json["labels"] = labels;
    }
    if (mounts != null) {
      _json["mounts"] = mounts.map((value) => (value).toJson()).toList();
    }
    if (pidNamespace != null) {
      _json["pidNamespace"] = pidNamespace;
    }
    if (portMappings != null) {
      _json["portMappings"] = portMappings;
    }
    if (publishExposedPorts != null) {
      _json["publishExposedPorts"] = publishExposedPorts;
    }
    if (runInBackground != null) {
      _json["runInBackground"] = runInBackground;
    }
    if (timeout != null) {
      _json["timeout"] = timeout;
    }
    return _json;
  }
}

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

  CancelOperationRequest.fromJson(core.Map _json) {}

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    return _json;
  }
}

/// An event generated when a container is forcibly terminated by the
/// worker. Currently, this only occurs when the container outlives the
/// timeout specified by the user.
class ContainerKilledEvent {
  /// The numeric ID of the action that started the container.
  core.int actionId;

  ContainerKilledEvent();

  ContainerKilledEvent.fromJson(core.Map _json) {
    if (_json.containsKey("actionId")) {
      actionId = _json["actionId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (actionId != null) {
      _json["actionId"] = actionId;
    }
    return _json;
  }
}

/// An event generated when a container starts.
class ContainerStartedEvent {
  /// The numeric ID of the action that started this container.
  core.int actionId;

  /// The public IP address that can be used to connect to the container. This
  /// field is only populated when at least one port mapping is present. If the
  /// instance was created with a private address, this field will be empty even
  /// if port mappings exist.
  core.String ipAddress;

  /// The container-to-host port mappings installed for this container. This
  /// set will contain any ports exposed using the `PUBLISH_EXPOSED_PORTS` flag
  /// as well as any specified in the `Action` definition.
  core.Map<core.String, core.int> portMappings;

  ContainerStartedEvent();

  ContainerStartedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("actionId")) {
      actionId = _json["actionId"];
    }
    if (_json.containsKey("ipAddress")) {
      ipAddress = _json["ipAddress"];
    }
    if (_json.containsKey("portMappings")) {
      portMappings =
          (_json["portMappings"] as core.Map).cast<core.String, core.int>();
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (actionId != null) {
      _json["actionId"] = actionId;
    }
    if (ipAddress != null) {
      _json["ipAddress"] = ipAddress;
    }
    if (portMappings != null) {
      _json["portMappings"] = portMappings;
    }
    return _json;
  }
}

/// An event generated when a container exits.
class ContainerStoppedEvent {
  /// The numeric ID of the action that started this container.
  core.int actionId;

  /// The exit status of the container.
  core.int exitStatus;

  /// The tail end of any content written to standard error by the container.
  /// If the content emits large amounts of debugging noise or contains
  /// sensitive information, you can prevent the content from being printed by
  /// setting the `DISABLE_STANDARD_ERROR_CAPTURE` flag.
  ///
  /// Note that only a small amount of the end of the stream is captured here.
  /// The entire stream is stored in the `/google/logs` directory mounted into
  /// each action, and can be copied off the machine as described elsewhere.
  core.String stderr;

  ContainerStoppedEvent();

  ContainerStoppedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("actionId")) {
      actionId = _json["actionId"];
    }
    if (_json.containsKey("exitStatus")) {
      exitStatus = _json["exitStatus"];
    }
    if (_json.containsKey("stderr")) {
      stderr = _json["stderr"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (actionId != null) {
      _json["actionId"] = actionId;
    }
    if (exitStatus != null) {
      _json["exitStatus"] = exitStatus;
    }
    if (stderr != null) {
      _json["stderr"] = stderr;
    }
    return _json;
  }
}

/// An event generated whenever a resource limitation or transient error
/// delays execution of a pipeline that was otherwise ready to run.
class DelayedEvent {
  /// A textual description of the cause of the delay. The string can change
  /// without notice because it is often generated by another service (such as
  /// Compute Engine).
  core.String cause;

  /// If the delay was caused by a resource shortage, this field lists the
  /// Compute Engine metrics that are preventing this operation from running
  /// (for example, `CPUS` or `INSTANCES`). If the particular metric is not
  /// known, a single `UNKNOWN` metric will be present.
  core.List<core.String> metrics;

  DelayedEvent();

  DelayedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("cause")) {
      cause = _json["cause"];
    }
    if (_json.containsKey("metrics")) {
      metrics = (_json["metrics"] 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 (cause != null) {
      _json["cause"] = cause;
    }
    if (metrics != null) {
      _json["metrics"] = metrics;
    }
    return _json;
  }
}

/// Carries information about a disk that can be attached to a VM.
///
/// See https://cloud.google.com/compute/docs/disks/performance for more
/// information about disk type, size, and performance considerations.
class Disk {
  /// A user-supplied name for the disk. Used when mounting the disk into
  /// actions. The name must contain only upper and lowercase alphanumeric
  /// characters and hyphens and cannot start with a hyphen.
  core.String name;

  /// The size, in GB, of the disk to attach. If the size is not
  /// specified, a default is chosen to ensure reasonable I/O performance.
  ///
  /// If the disk type is specified as `local-ssd`, multiple local drives are
  /// automatically combined to provide the requested size. Note, however, that
  /// each physical SSD is 375GB in size, and no more than 8 drives can be
  /// attached to a single instance.
  core.int sizeGb;

  /// An optional image to put on the disk before attaching it to the VM.
  core.String sourceImage;

  /// The Compute Engine disk type. If unspecified, `pd-standard` is used.
  core.String type;

  Disk();

  Disk.fromJson(core.Map _json) {
    if (_json.containsKey("name")) {
      name = _json["name"];
    }
    if (_json.containsKey("sizeGb")) {
      sizeGb = _json["sizeGb"];
    }
    if (_json.containsKey("sourceImage")) {
      sourceImage = _json["sourceImage"];
    }
    if (_json.containsKey("type")) {
      type = _json["type"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (name != null) {
      _json["name"] = name;
    }
    if (sizeGb != null) {
      _json["sizeGb"] = sizeGb;
    }
    if (sourceImage != null) {
      _json["sourceImage"] = sourceImage;
    }
    if (type != null) {
      _json["type"] = type;
    }
    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;
  }
}

/// Carries information about events that occur during pipeline execution.
class Event {
  /// See google.cloud.lifesciences.v2beta.ContainerKilledEvent.
  ContainerKilledEvent containerKilled;

  /// See google.cloud.lifesciences.v2beta.ContainerStartedEvent.
  ContainerStartedEvent containerStarted;

  /// See google.cloud.lifesciences.v2beta.ContainerStoppedEvent.
  ContainerStoppedEvent containerStopped;

  /// See google.cloud.lifesciences.v2beta.DelayedEvent.
  DelayedEvent delayed;

  /// A human-readable description of the event. Note that these strings can
  /// change at any time without notice. Any application logic must use the
  /// information in the `details` field.
  core.String description;

  /// See google.cloud.lifesciences.v2beta.FailedEvent.
  FailedEvent failed;

  /// See google.cloud.lifesciences.v2beta.PullStartedEvent.
  PullStartedEvent pullStarted;

  /// See google.cloud.lifesciences.v2beta.PullStoppedEvent.
  PullStoppedEvent pullStopped;

  /// The time at which the event occurred.
  core.String timestamp;

  /// See google.cloud.lifesciences.v2beta.UnexpectedExitStatusEvent.
  UnexpectedExitStatusEvent unexpectedExitStatus;

  /// See google.cloud.lifesciences.v2beta.WorkerAssignedEvent.
  WorkerAssignedEvent workerAssigned;

  /// See google.cloud.lifesciences.v2beta.WorkerReleasedEvent.
  WorkerReleasedEvent workerReleased;

  Event();

  Event.fromJson(core.Map _json) {
    if (_json.containsKey("containerKilled")) {
      containerKilled =
          new ContainerKilledEvent.fromJson(_json["containerKilled"]);
    }
    if (_json.containsKey("containerStarted")) {
      containerStarted =
          new ContainerStartedEvent.fromJson(_json["containerStarted"]);
    }
    if (_json.containsKey("containerStopped")) {
      containerStopped =
          new ContainerStoppedEvent.fromJson(_json["containerStopped"]);
    }
    if (_json.containsKey("delayed")) {
      delayed = new DelayedEvent.fromJson(_json["delayed"]);
    }
    if (_json.containsKey("description")) {
      description = _json["description"];
    }
    if (_json.containsKey("failed")) {
      failed = new FailedEvent.fromJson(_json["failed"]);
    }
    if (_json.containsKey("pullStarted")) {
      pullStarted = new PullStartedEvent.fromJson(_json["pullStarted"]);
    }
    if (_json.containsKey("pullStopped")) {
      pullStopped = new PullStoppedEvent.fromJson(_json["pullStopped"]);
    }
    if (_json.containsKey("timestamp")) {
      timestamp = _json["timestamp"];
    }
    if (_json.containsKey("unexpectedExitStatus")) {
      unexpectedExitStatus =
          new UnexpectedExitStatusEvent.fromJson(_json["unexpectedExitStatus"]);
    }
    if (_json.containsKey("workerAssigned")) {
      workerAssigned =
          new WorkerAssignedEvent.fromJson(_json["workerAssigned"]);
    }
    if (_json.containsKey("workerReleased")) {
      workerReleased =
          new WorkerReleasedEvent.fromJson(_json["workerReleased"]);
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (containerKilled != null) {
      _json["containerKilled"] = (containerKilled).toJson();
    }
    if (containerStarted != null) {
      _json["containerStarted"] = (containerStarted).toJson();
    }
    if (containerStopped != null) {
      _json["containerStopped"] = (containerStopped).toJson();
    }
    if (delayed != null) {
      _json["delayed"] = (delayed).toJson();
    }
    if (description != null) {
      _json["description"] = description;
    }
    if (failed != null) {
      _json["failed"] = (failed).toJson();
    }
    if (pullStarted != null) {
      _json["pullStarted"] = (pullStarted).toJson();
    }
    if (pullStopped != null) {
      _json["pullStopped"] = (pullStopped).toJson();
    }
    if (timestamp != null) {
      _json["timestamp"] = timestamp;
    }
    if (unexpectedExitStatus != null) {
      _json["unexpectedExitStatus"] = (unexpectedExitStatus).toJson();
    }
    if (workerAssigned != null) {
      _json["workerAssigned"] = (workerAssigned).toJson();
    }
    if (workerReleased != null) {
      _json["workerReleased"] = (workerReleased).toJson();
    }
    return _json;
  }
}

/// An event generated when the execution of a pipeline has failed. Note
/// that other events can continue to occur after this event.
class FailedEvent {
  /// The human-readable description of the cause of the failure.
  core.String cause;

  /// The Google standard error code that best describes this failure.
  /// Possible string values are:
  /// - "OK" : Not an error; returned on success
  ///
  /// HTTP Mapping: 200 OK
  /// - "CANCELLED" : The operation was cancelled, typically by the caller.
  ///
  /// HTTP Mapping: 499 Client Closed Request
  /// - "UNKNOWN" : Unknown error.  For example, this error may be returned when
  /// a `Status` value received from another address space belongs to
  /// an error space that is not known in this address space.  Also
  /// errors raised by APIs that do not return enough error information
  /// may be converted to this error.
  ///
  /// HTTP Mapping: 500 Internal Server Error
  /// - "INVALID_ARGUMENT" : The client specified an invalid argument.  Note
  /// that this differs
  /// from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments
  /// that are problematic regardless of the state of the system
  /// (e.g., a malformed file name).
  ///
  /// HTTP Mapping: 400 Bad Request
  /// - "DEADLINE_EXCEEDED" : The deadline expired before the operation could
  /// complete. For operations
  /// that change the state of the system, this error may be returned
  /// even if the operation has completed successfully.  For example, a
  /// successful response from a server could have been delayed long
  /// enough for the deadline to expire.
  ///
  /// HTTP Mapping: 504 Gateway Timeout
  /// - "NOT_FOUND" : Some requested entity (e.g., file or directory) was not
  /// found.
  ///
  /// Note to server developers: if a request is denied for an entire class
  /// of users, such as gradual feature rollout or undocumented whitelist,
  /// `NOT_FOUND` may be used. If a request is denied for some users within
  /// a class of users, such as user-based access control, `PERMISSION_DENIED`
  /// must be used.
  ///
  /// HTTP Mapping: 404 Not Found
  /// - "ALREADY_EXISTS" : The entity that a client attempted to create (e.g.,
  /// file or directory)
  /// already exists.
  ///
  /// HTTP Mapping: 409 Conflict
  /// - "PERMISSION_DENIED" : The caller does not have permission to execute the
  /// specified
  /// operation. `PERMISSION_DENIED` must not be used for rejections
  /// caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
  /// instead for those errors). `PERMISSION_DENIED` must not be
  /// used if the caller can not be identified (use `UNAUTHENTICATED`
  /// instead for those errors). This error code does not imply the
  /// request is valid or the requested entity exists or satisfies
  /// other pre-conditions.
  ///
  /// HTTP Mapping: 403 Forbidden
  /// - "UNAUTHENTICATED" : The request does not have valid authentication
  /// credentials for the
  /// operation.
  ///
  /// HTTP Mapping: 401 Unauthorized
  /// - "RESOURCE_EXHAUSTED" : Some resource has been exhausted, perhaps a
  /// per-user quota, or
  /// perhaps the entire file system is out of space.
  ///
  /// HTTP Mapping: 429 Too Many Requests
  /// - "FAILED_PRECONDITION" : The operation was rejected because the system is
  /// not in a state
  /// required for the operation's execution.  For example, the directory
  /// to be deleted is non-empty, an rmdir operation is applied to
  /// a non-directory, etc.
  ///
  /// Service implementors can use the following guidelines to decide
  /// between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
  ///  (a) Use `UNAVAILABLE` if the client can retry just the failing call.
  ///  (b) Use `ABORTED` if the client should retry at a higher level
  ///      (e.g., when a client-specified test-and-set fails, indicating the
  ///      client should restart a read-modify-write sequence).
  ///  (c) Use `FAILED_PRECONDITION` if the client should not retry until
  ///      the system state has been explicitly fixed.  E.g., if an "rmdir"
  ///      fails because the directory is non-empty, `FAILED_PRECONDITION`
  ///      should be returned since the client should not retry unless
  ///      the files are deleted from the directory.
  ///
  /// HTTP Mapping: 400 Bad Request
  /// - "ABORTED" : The operation was aborted, typically due to a concurrency
  /// issue such as
  /// a sequencer check failure or transaction abort.
  ///
  /// See the guidelines above for deciding between `FAILED_PRECONDITION`,
  /// `ABORTED`, and `UNAVAILABLE`.
  ///
  /// HTTP Mapping: 409 Conflict
  /// - "OUT_OF_RANGE" : The operation was attempted past the valid range.
  /// E.g., seeking or
  /// reading past end-of-file.
  ///
  /// Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
  /// be fixed if the system state changes. For example, a 32-bit file
  /// system will generate `INVALID_ARGUMENT` if asked to read at an
  /// offset that is not in the range [0,2^32-1], but it will generate
  /// `OUT_OF_RANGE` if asked to read from an offset past the current
  /// file size.
  ///
  /// There is a fair bit of overlap between `FAILED_PRECONDITION` and
  /// `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific
  /// error) when it applies so that callers who are iterating through
  /// a space can easily look for an `OUT_OF_RANGE` error to detect when
  /// they are done.
  ///
  /// HTTP Mapping: 400 Bad Request
  /// - "UNIMPLEMENTED" : The operation is not implemented or is not
  /// supported/enabled in this
  /// service.
  ///
  /// HTTP Mapping: 501 Not Implemented
  /// - "INTERNAL" : Internal errors.  This means that some invariants expected
  /// by the
  /// underlying system have been broken.  This error code is reserved
  /// for serious errors.
  ///
  /// HTTP Mapping: 500 Internal Server Error
  /// - "UNAVAILABLE" : The service is currently unavailable.  This is most
  /// likely a
  /// transient condition, which can be corrected by retrying with
  /// a backoff. Note that it is not always safe to retry
  /// non-idempotent operations.
  ///
  /// See the guidelines above for deciding between `FAILED_PRECONDITION`,
  /// `ABORTED`, and `UNAVAILABLE`.
  ///
  /// HTTP Mapping: 503 Service Unavailable
  /// - "DATA_LOSS" : Unrecoverable data loss or corruption.
  ///
  /// HTTP Mapping: 500 Internal Server Error
  core.String code;

  FailedEvent();

  FailedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("cause")) {
      cause = _json["cause"];
    }
    if (_json.containsKey("code")) {
      code = _json["code"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (cause != null) {
      _json["cause"] = cause;
    }
    if (code != null) {
      _json["code"] = code;
    }
    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;
  }
}

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

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

  ListOperationsResponse();

  ListOperationsResponse.fromJson(core.Map _json) {
    if (_json.containsKey("nextPageToken")) {
      nextPageToken = _json["nextPageToken"];
    }
    if (_json.containsKey("operations")) {
      operations = (_json["operations"] as core.List)
          .map<Operation>((value) => new Operation.fromJson(value))
          .toList();
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (nextPageToken != null) {
      _json["nextPageToken"] = nextPageToken;
    }
    if (operations != null) {
      _json["operations"] =
          operations.map((value) => (value).toJson()).toList();
    }
    return _json;
  }
}

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

/// Carries information about the pipeline execution that is returned
/// in the long running operation's metadata field.
class Metadata {
  /// The time at which the operation was created by the API.
  core.String createTime;

  /// The time at which execution was completed and resources were cleaned up.
  core.String endTime;

  /// The list of events that have happened so far during the execution of this
  /// operation.
  core.List<Event> events;

  /// The user-defined labels associated with this operation.
  core.Map<core.String, core.String> labels;

  /// The pipeline this operation represents.
  Pipeline pipeline;

  /// The first time at which resources were allocated to execute the pipeline.
  core.String startTime;

  Metadata();

  Metadata.fromJson(core.Map _json) {
    if (_json.containsKey("createTime")) {
      createTime = _json["createTime"];
    }
    if (_json.containsKey("endTime")) {
      endTime = _json["endTime"];
    }
    if (_json.containsKey("events")) {
      events = (_json["events"] as core.List)
          .map<Event>((value) => new Event.fromJson(value))
          .toList();
    }
    if (_json.containsKey("labels")) {
      labels = (_json["labels"] as core.Map).cast<core.String, core.String>();
    }
    if (_json.containsKey("pipeline")) {
      pipeline = new Pipeline.fromJson(_json["pipeline"]);
    }
    if (_json.containsKey("startTime")) {
      startTime = _json["startTime"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (createTime != null) {
      _json["createTime"] = createTime;
    }
    if (endTime != null) {
      _json["endTime"] = endTime;
    }
    if (events != null) {
      _json["events"] = events.map((value) => (value).toJson()).toList();
    }
    if (labels != null) {
      _json["labels"] = labels;
    }
    if (pipeline != null) {
      _json["pipeline"] = (pipeline).toJson();
    }
    if (startTime != null) {
      _json["startTime"] = startTime;
    }
    return _json;
  }
}

/// Carries information about a particular disk mount inside a container.
class Mount {
  /// The name of the disk to mount, as specified in the resources section.
  core.String disk;

  /// The path to mount the disk inside the container.
  core.String path;

  /// If true, the disk is mounted read-only inside the container.
  core.bool readOnly;

  Mount();

  Mount.fromJson(core.Map _json) {
    if (_json.containsKey("disk")) {
      disk = _json["disk"];
    }
    if (_json.containsKey("path")) {
      path = _json["path"];
    }
    if (_json.containsKey("readOnly")) {
      readOnly = _json["readOnly"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (disk != null) {
      _json["disk"] = disk;
    }
    if (path != null) {
      _json["path"] = path;
    }
    if (readOnly != null) {
      _json["readOnly"] = readOnly;
    }
    return _json;
  }
}

/// VM networking options.
class Network {
  /// The network name to attach the VM's network interface to. The value will
  /// be prefixed with `global/networks/` unless it contains a `/`, in which
  /// case it is assumed to be a fully specified network resource URL.
  ///
  /// If unspecified, the global default network is used.
  core.String network;

  /// If the specified network is configured for custom subnet creation, the
  /// name of the subnetwork to attach the instance to must be specified here.
  ///
  /// The value is prefixed with `regions / * /subnetworks/` unless it contains
  /// a
  /// `/`, in which case it is assumed to be a fully specified subnetwork
  /// resource URL.
  ///
  /// If the `*` character appears in the value, it is replaced with the region
  /// that the virtual machine has been allocated in.
  core.String subnetwork;

  /// If set to true, do not attach a public IP address to the VM. Note that
  /// without a public IP address, additional configuration is required to
  /// allow the VM to access Google services.
  ///
  /// See https://cloud.google.com/vpc/docs/configure-private-google-access
  /// for more information.
  core.bool usePrivateAddress;

  Network();

  Network.fromJson(core.Map _json) {
    if (_json.containsKey("network")) {
      network = _json["network"];
    }
    if (_json.containsKey("subnetwork")) {
      subnetwork = _json["subnetwork"];
    }
    if (_json.containsKey("usePrivateAddress")) {
      usePrivateAddress = _json["usePrivateAddress"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (network != null) {
      _json["network"] = network;
    }
    if (subnetwork != null) {
      _json["subnetwork"] = subnetwork;
    }
    if (usePrivateAddress != null) {
      _json["usePrivateAddress"] = usePrivateAddress;
    }
    return _json;
  }
}

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

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

  /// An Metadata object. This will always be returned with the Operation.
  ///
  /// The values for Object must be JSON objects. It can consist of `num`,
  /// `String`, `bool` and `null` as well as `Map` and `List` values.
  core.Map<core.String, core.Object> metadata;

  /// The server-assigned name for the operation.  This may be passed to the
  /// other operation methods to retrieve information about the operation's
  /// status.
  core.String name;

  /// An Empty object.
  ///
  /// The values for Object must be JSON objects. It can consist of `num`,
  /// `String`, `bool` and `null` as well as `Map` and `List` values.
  core.Map<core.String, core.Object> response;

  Operation();

  Operation.fromJson(core.Map _json) {
    if (_json.containsKey("done")) {
      done = _json["done"];
    }
    if (_json.containsKey("error")) {
      error = new Status.fromJson(_json["error"]);
    }
    if (_json.containsKey("metadata")) {
      metadata =
          (_json["metadata"] as core.Map).cast<core.String, core.Object>();
    }
    if (_json.containsKey("name")) {
      name = _json["name"];
    }
    if (_json.containsKey("response")) {
      response =
          (_json["response"] as core.Map).cast<core.String, core.Object>();
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (done != null) {
      _json["done"] = done;
    }
    if (error != null) {
      _json["error"] = (error).toJson();
    }
    if (metadata != null) {
      _json["metadata"] = metadata;
    }
    if (name != null) {
      _json["name"] = name;
    }
    if (response != null) {
      _json["response"] = response;
    }
    return _json;
  }
}

/// Specifies a series of actions to execute, expressed as Docker containers.
class Pipeline {
  /// The list of actions to execute, in the order they are specified.
  core.List<Action> actions;

  /// The environment to pass into every action. Each action can also specify
  /// additional environment variables but cannot delete an entry from this map
  /// (though they can overwrite it with a different value).
  core.Map<core.String, core.String> environment;

  /// The resources required for execution.
  Resources resources;

  /// The maximum amount of time to give the pipeline to complete.  This
  /// includes
  /// the time spent waiting for a worker to be allocated.  If the pipeline
  /// fails
  /// to complete before the timeout, it will be cancelled and the error code
  /// will be set to DEADLINE_EXCEEDED.
  ///
  /// If unspecified, it will default to 7 days.
  core.String timeout;

  Pipeline();

  Pipeline.fromJson(core.Map _json) {
    if (_json.containsKey("actions")) {
      actions = (_json["actions"] as core.List)
          .map<Action>((value) => new Action.fromJson(value))
          .toList();
    }
    if (_json.containsKey("environment")) {
      environment =
          (_json["environment"] as core.Map).cast<core.String, core.String>();
    }
    if (_json.containsKey("resources")) {
      resources = new Resources.fromJson(_json["resources"]);
    }
    if (_json.containsKey("timeout")) {
      timeout = _json["timeout"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (actions != null) {
      _json["actions"] = actions.map((value) => (value).toJson()).toList();
    }
    if (environment != null) {
      _json["environment"] = environment;
    }
    if (resources != null) {
      _json["resources"] = (resources).toJson();
    }
    if (timeout != null) {
      _json["timeout"] = timeout;
    }
    return _json;
  }
}

/// An event generated when the worker starts pulling an image.
class PullStartedEvent {
  /// The URI of the image that was pulled.
  core.String imageUri;

  PullStartedEvent();

  PullStartedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("imageUri")) {
      imageUri = _json["imageUri"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (imageUri != null) {
      _json["imageUri"] = imageUri;
    }
    return _json;
  }
}

/// An event generated when the worker stops pulling an image.
class PullStoppedEvent {
  /// The URI of the image that was pulled.
  core.String imageUri;

  PullStoppedEvent();

  PullStoppedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("imageUri")) {
      imageUri = _json["imageUri"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (imageUri != null) {
      _json["imageUri"] = imageUri;
    }
    return _json;
  }
}

/// The system resources for the pipeline run.
///
/// At least one zone or region must be specified or the pipeline run will fail.
class Resources {
  /// The list of regions allowed for VM allocation. If set, the `zones` field
  /// must not be set.
  core.List<core.String> regions;

  /// The virtual machine specification.
  VirtualMachine virtualMachine;

  /// The list of zones allowed for VM allocation. If set, the `regions` field
  /// must not be set.
  core.List<core.String> zones;

  Resources();

  Resources.fromJson(core.Map _json) {
    if (_json.containsKey("regions")) {
      regions = (_json["regions"] as core.List).cast<core.String>();
    }
    if (_json.containsKey("virtualMachine")) {
      virtualMachine = new VirtualMachine.fromJson(_json["virtualMachine"]);
    }
    if (_json.containsKey("zones")) {
      zones = (_json["zones"] 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 (regions != null) {
      _json["regions"] = regions;
    }
    if (virtualMachine != null) {
      _json["virtualMachine"] = (virtualMachine).toJson();
    }
    if (zones != null) {
      _json["zones"] = zones;
    }
    return _json;
  }
}

/// The arguments to the `RunPipeline` method. The requesting user must have
/// the `iam.serviceAccounts.actAs` permission for the Cloud Life Sciences
/// service account or the request will fail.
class RunPipelineRequest {
  /// User-defined labels to associate with the returned operation. These
  /// labels are not propagated to any Google Cloud Platform resources used by
  /// the operation, and can be modified at any time.
  ///
  /// To associate labels with resources created while executing the operation,
  /// see the appropriate resource message (for example, `VirtualMachine`).
  core.Map<core.String, core.String> labels;

  /// Required. The description of the pipeline to run.
  Pipeline pipeline;

  RunPipelineRequest();

  RunPipelineRequest.fromJson(core.Map _json) {
    if (_json.containsKey("labels")) {
      labels = (_json["labels"] as core.Map).cast<core.String, core.String>();
    }
    if (_json.containsKey("pipeline")) {
      pipeline = new Pipeline.fromJson(_json["pipeline"]);
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (labels != null) {
      _json["labels"] = labels;
    }
    if (pipeline != null) {
      _json["pipeline"] = (pipeline).toJson();
    }
    return _json;
  }
}

/// The response to the RunPipeline method, returned in the operation's result
/// field on success.
class RunPipelineResponse {
  RunPipelineResponse();

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

/// Holds encrypted information that is only decrypted and stored in RAM
/// by the worker VM when running the pipeline.
class Secret {
  /// The value of the cipherText response from the `encrypt` method. This field
  /// is intentionally unaudited.
  core.String cipherText;

  /// The name of the Cloud KMS key that will be used to decrypt the secret
  /// value. The VM service account must have the required permissions and
  /// authentication scopes to invoke the `decrypt` method on the specified key.
  core.String keyName;

  Secret();

  Secret.fromJson(core.Map _json) {
    if (_json.containsKey("cipherText")) {
      cipherText = _json["cipherText"];
    }
    if (_json.containsKey("keyName")) {
      keyName = _json["keyName"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (cipherText != null) {
      _json["cipherText"] = cipherText;
    }
    if (keyName != null) {
      _json["keyName"] = keyName;
    }
    return _json;
  }
}

/// Carries information about a Google Cloud service account.
class ServiceAccount {
  /// Email address of the service account. If not specified, the default
  /// Compute Engine service account for the project will be used.
  core.String email;

  /// List of scopes to be enabled for this service account on the VM, in
  /// addition to the cloud-platform API scope that will be added by default.
  core.List<core.String> scopes;

  ServiceAccount();

  ServiceAccount.fromJson(core.Map _json) {
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("scopes")) {
      scopes = (_json["scopes"] 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 (email != null) {
      _json["email"] = email;
    }
    if (scopes != null) {
      _json["scopes"] = scopes;
    }
    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;
  }
}

/// An event generated when the execution of a container results in a
/// non-zero exit status that was not otherwise ignored. Execution will
/// continue, but only actions that are flagged as `ALWAYS_RUN` will be
/// executed. Other actions will be skipped.
class UnexpectedExitStatusEvent {
  /// The numeric ID of the action that started the container.
  core.int actionId;

  /// The exit status of the container.
  core.int exitStatus;

  UnexpectedExitStatusEvent();

  UnexpectedExitStatusEvent.fromJson(core.Map _json) {
    if (_json.containsKey("actionId")) {
      actionId = _json["actionId"];
    }
    if (_json.containsKey("exitStatus")) {
      exitStatus = _json["exitStatus"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (actionId != null) {
      _json["actionId"] = actionId;
    }
    if (exitStatus != null) {
      _json["exitStatus"] = exitStatus;
    }
    return _json;
  }
}

/// Carries information about a Compute Engine VM resource.
class VirtualMachine {
  /// The list of accelerators to attach to the VM.
  core.List<Accelerator> accelerators;

  /// The size of the boot disk, in GB. The boot disk must be large
  /// enough to accommodate all of the Docker images from each action in the
  /// pipeline at the same time. If not specified, a small but reasonable
  /// default value is used.
  core.int bootDiskSizeGb;

  /// The host operating system image to use.
  ///
  /// Currently, only Container-Optimized OS images can be used.
  ///
  /// The default value is `projects/cos-cloud/global/images/family/cos-stable`,
  /// which selects the latest stable release of Container-Optimized OS.
  ///
  /// This option is provided to allow testing against the beta release of the
  /// operating system to ensure that the new version does not interact
  /// negatively with production pipelines.
  ///
  /// To test a pipeline against the beta release of Container-Optimized OS,
  /// use the value `projects/cos-cloud/global/images/family/cos-beta`.
  core.String bootImage;

  /// The CPU platform to request. An instance based on a newer platform can be
  /// allocated, but never one with fewer capabilities. The value of this
  /// parameter must be a valid Compute Engine CPU platform name (such as "Intel
  /// Skylake"). This parameter is only useful for carefully optimized work
  /// loads where the CPU platform has a significant impact.
  ///
  /// For more information about the effect of this parameter, see
  /// https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform.
  core.String cpuPlatform;

  /// The list of disks to create and attach to the VM.
  core.List<Disk> disks;

  /// Whether Stackdriver monitoring should be enabled on the VM.
  core.bool enableStackdriverMonitoring;

  /// Optional set of labels to apply to the VM and any attached disk resources.
  /// These labels must adhere to the [name and value
  /// restrictions](https://cloud.google.com/compute/docs/labeling-resources) on
  /// VM labels imposed by Compute Engine.
  ///
  /// Labels keys with the prefix 'google-' are reserved for use by Google.
  ///
  /// Labels applied at creation time to the VM. Applied on a best-effort basis
  /// to attached disk resources shortly after VM creation.
  core.Map<core.String, core.String> labels;

  /// Required. The machine type of the virtual machine to create. Must be the
  /// short name
  /// of a standard machine type (such as "n1-standard-1") or a custom machine
  /// type (such as "custom-1-4096", where "1" indicates the number of vCPUs and
  /// "4096" indicates the memory in MB). See
  /// [Creating an instance with a custom machine
  /// type](https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#create)
  /// for more specifications on creating a custom machine type.
  core.String machineType;

  /// The VM network configuration.
  Network network;

  /// The NVIDIA driver version to use when attaching an NVIDIA GPU accelerator.
  /// The version specified here must be compatible with the GPU libraries
  /// contained in the container being executed, and must be one of the drivers
  /// hosted in the `nvidia-drivers-us-public` bucket on Google Cloud Storage.
  core.String nvidiaDriverVersion;

  /// If true, allocate a preemptible VM.
  core.bool preemptible;

  /// The service account to install on the VM. This account does not need
  /// any permissions other than those required by the pipeline.
  ServiceAccount serviceAccount;

  VirtualMachine();

  VirtualMachine.fromJson(core.Map _json) {
    if (_json.containsKey("accelerators")) {
      accelerators = (_json["accelerators"] as core.List)
          .map<Accelerator>((value) => new Accelerator.fromJson(value))
          .toList();
    }
    if (_json.containsKey("bootDiskSizeGb")) {
      bootDiskSizeGb = _json["bootDiskSizeGb"];
    }
    if (_json.containsKey("bootImage")) {
      bootImage = _json["bootImage"];
    }
    if (_json.containsKey("cpuPlatform")) {
      cpuPlatform = _json["cpuPlatform"];
    }
    if (_json.containsKey("disks")) {
      disks = (_json["disks"] as core.List)
          .map<Disk>((value) => new Disk.fromJson(value))
          .toList();
    }
    if (_json.containsKey("enableStackdriverMonitoring")) {
      enableStackdriverMonitoring = _json["enableStackdriverMonitoring"];
    }
    if (_json.containsKey("labels")) {
      labels = (_json["labels"] as core.Map).cast<core.String, core.String>();
    }
    if (_json.containsKey("machineType")) {
      machineType = _json["machineType"];
    }
    if (_json.containsKey("network")) {
      network = new Network.fromJson(_json["network"]);
    }
    if (_json.containsKey("nvidiaDriverVersion")) {
      nvidiaDriverVersion = _json["nvidiaDriverVersion"];
    }
    if (_json.containsKey("preemptible")) {
      preemptible = _json["preemptible"];
    }
    if (_json.containsKey("serviceAccount")) {
      serviceAccount = new ServiceAccount.fromJson(_json["serviceAccount"]);
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (accelerators != null) {
      _json["accelerators"] =
          accelerators.map((value) => (value).toJson()).toList();
    }
    if (bootDiskSizeGb != null) {
      _json["bootDiskSizeGb"] = bootDiskSizeGb;
    }
    if (bootImage != null) {
      _json["bootImage"] = bootImage;
    }
    if (cpuPlatform != null) {
      _json["cpuPlatform"] = cpuPlatform;
    }
    if (disks != null) {
      _json["disks"] = disks.map((value) => (value).toJson()).toList();
    }
    if (enableStackdriverMonitoring != null) {
      _json["enableStackdriverMonitoring"] = enableStackdriverMonitoring;
    }
    if (labels != null) {
      _json["labels"] = labels;
    }
    if (machineType != null) {
      _json["machineType"] = machineType;
    }
    if (network != null) {
      _json["network"] = (network).toJson();
    }
    if (nvidiaDriverVersion != null) {
      _json["nvidiaDriverVersion"] = nvidiaDriverVersion;
    }
    if (preemptible != null) {
      _json["preemptible"] = preemptible;
    }
    if (serviceAccount != null) {
      _json["serviceAccount"] = (serviceAccount).toJson();
    }
    return _json;
  }
}

/// An event generated after a worker VM has been assigned to run the
/// pipeline.
class WorkerAssignedEvent {
  /// The worker's instance name.
  core.String instance;

  /// The machine type that was assigned for the worker.
  core.String machineType;

  /// The zone the worker is running in.
  core.String zone;

  WorkerAssignedEvent();

  WorkerAssignedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("instance")) {
      instance = _json["instance"];
    }
    if (_json.containsKey("machineType")) {
      machineType = _json["machineType"];
    }
    if (_json.containsKey("zone")) {
      zone = _json["zone"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (instance != null) {
      _json["instance"] = instance;
    }
    if (machineType != null) {
      _json["machineType"] = machineType;
    }
    if (zone != null) {
      _json["zone"] = zone;
    }
    return _json;
  }
}

/// An event generated when the worker VM that was assigned to the pipeline
/// has been released (deleted).
class WorkerReleasedEvent {
  /// The worker's instance name.
  core.String instance;

  /// The zone the worker was running in.
  core.String zone;

  WorkerReleasedEvent();

  WorkerReleasedEvent.fromJson(core.Map _json) {
    if (_json.containsKey("instance")) {
      instance = _json["instance"];
    }
    if (_json.containsKey("zone")) {
      zone = _json["zone"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (instance != null) {
      _json["instance"] = instance;
    }
    if (zone != null) {
      _json["zone"] = zone;
    }
    return _json;
  }
}