data.proto

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

syntax = "proto3";

package google.events.cloud.notebooks.v1;

import "google/protobuf/timestamp.proto";

option csharp_namespace = "Google.Events.Protobuf.Cloud.Notebooks.V1";
option php_namespace = "Google\\Events\\Cloud\\Notebooks\\V1";
option ruby_package = "Google::Events::Cloud::Notebooks::V1";

// Definition of a software environment that is used to start a notebook
// instance.
message Environment {
  // Output only. Name of this environment.
  // Format:
  // `projects/{project_id}/locations/{location}/environments/{environment_id}`
  string name = 1;

  // Display name of this environment for the UI.
  string display_name = 2;

  // A brief description of this environment.
  string description = 3;

  // Type of the environment; can be one of VM image, or container image.
  oneof image_type {
    // Use a Compute Engine VM image to start the notebook instance.
    VmImage vm_image = 6;

    // Use a container image to start the notebook instance.
    ContainerImage container_image = 7;
  }

  // Path to a Bash script that automatically runs after a notebook instance
  // fully boots up. The path must be a URL or
  // Cloud Storage path. Example: `"gs://path-to-file/file-name"`
  string post_startup_script = 8;

  // Output only. The time at which this environment was created.
  google.protobuf.Timestamp create_time = 9;
}

// Definition of a custom Compute Engine virtual machine image for starting a
// notebook instance with the environment installed directly on the VM.
message VmImage {
  // Required. The name of the Google Cloud project that this VM image belongs
  // to. Format: `{project_id}`
  string project = 1;

  // The reference to an external Compute Engine VM image.
  oneof image {
    // Use VM image name to find the image.
    string image_name = 2;

    // Use this VM image family to find the image; the newest image in this
    // family will be used.
    string image_family = 3;
  }
}

// Definition of a container image for starting a notebook instance with the
// environment installed in a container.
message ContainerImage {
  // Required. The path to the container image repository. For example:
  // `gcr.io/{project_id}/{image_name}`
  string repository = 1;

  // The tag of the container image. If not specified, this defaults
  // to the latest tag.
  string tag = 2;
}

// The definition of a Runtime for a managed notebook instance.
message Runtime {
  // The definition of the states of this runtime.
  enum State {
    // State is not specified.
    STATE_UNSPECIFIED = 0;

    // The compute layer is starting the runtime. It is not ready for use.
    STARTING = 1;

    // The compute layer is installing required frameworks and registering the
    // runtime with notebook proxy. It cannot be used.
    PROVISIONING = 2;

    // The runtime is currently running. It is ready for use.
    ACTIVE = 3;

    // The control logic is stopping the runtime. It cannot be used.
    STOPPING = 4;

    // The runtime is stopped. It cannot be used.
    STOPPED = 5;

    // The runtime is being deleted. It cannot be used.
    DELETING = 6;

    // The runtime is upgrading. It cannot be used.
    UPGRADING = 7;

    // The runtime is being created and set up. It is not ready for use.
    INITIALIZING = 8;
  }

  // The runtime substate.
  enum HealthState {
    // The runtime substate is unknown.
    HEALTH_STATE_UNSPECIFIED = 0;

    // The runtime is known to be in an healthy state
    // (for example, critical daemons are running)
    // Applies to ACTIVE state.
    HEALTHY = 1;

    // The runtime is known to be in an unhealthy state
    // (for example, critical daemons are not running)
    // Applies to ACTIVE state.
    UNHEALTHY = 2;

    // The runtime has not installed health monitoring agent.
    // Applies to ACTIVE state.
    AGENT_NOT_INSTALLED = 3;

    // The runtime health monitoring agent is not running.
    // Applies to ACTIVE state.
    AGENT_NOT_RUNNING = 4;
  }

  // Output only. The resource name of the runtime.
  // Format:
  // `projects/{project}/locations/{location}/runtimes/{runtimeId}`
  string name = 1;

  // Type of the runtime; currently only supports Compute Engine VM.
  oneof runtime_type {
    // Use a Compute Engine VM image to start the managed notebook instance.
    VirtualMachine virtual_machine = 2;
  }

  // Output only. Runtime state.
  State state = 3;

  // Output only. Runtime health_state.
  HealthState health_state = 4;

  // The config settings for accessing runtime.
  RuntimeAccessConfig access_config = 5;

  // The config settings for software inside the runtime.
  RuntimeSoftwareConfig software_config = 6;

  // Output only. Contains Runtime daemon metrics such as Service status and
  // JupyterLab stats.
  RuntimeMetrics metrics = 7;

  // Output only. Runtime creation time.
  google.protobuf.Timestamp create_time = 20;

  // Output only. Runtime update time.
  google.protobuf.Timestamp update_time = 21;

  // Optional. The labels to associate with this Managed Notebook or Runtime.
  // Label **keys** must contain 1 to 63 characters, and must conform to
  // [RFC 1035](https://www.ietf.org/rfc/rfc1035.txt).
  // Label **values** may be empty, but, if present, must contain 1 to 63
  // characters, and must conform to [RFC
  // 1035](https://www.ietf.org/rfc/rfc1035.txt). No more than 32 labels can be
  // associated with a cluster.
  map<string, string> labels = 23;
}

// Definition of the types of hardware accelerators that can be used.
// Definition of the types of hardware accelerators that can be used.
// See [Compute Engine
// AcceleratorTypes](https://cloud.google.com/compute/docs/reference/beta/acceleratorTypes).
// Examples:
//
// * `nvidia-tesla-k80`
// * `nvidia-tesla-p100`
// * `nvidia-tesla-v100`
// * `nvidia-tesla-p4`
// * `nvidia-tesla-t4`
// * `nvidia-tesla-a100`
message RuntimeAcceleratorConfig {
  // Type of this accelerator.
  enum AcceleratorType {
    // Accelerator type is not specified.
    ACCELERATOR_TYPE_UNSPECIFIED = 0;

    // Accelerator type is Nvidia Tesla K80.
    NVIDIA_TESLA_K80 = 1;

    // Accelerator type is Nvidia Tesla P100.
    NVIDIA_TESLA_P100 = 2;

    // Accelerator type is Nvidia Tesla V100.
    NVIDIA_TESLA_V100 = 3;

    // Accelerator type is Nvidia Tesla P4.
    NVIDIA_TESLA_P4 = 4;

    // Accelerator type is Nvidia Tesla T4.
    NVIDIA_TESLA_T4 = 5;

    // Accelerator type is Nvidia Tesla A100 - 40GB.
    NVIDIA_TESLA_A100 = 6;

    // (Coming soon) Accelerator type is TPU V2.
    TPU_V2 = 7;

    // (Coming soon) Accelerator type is TPU V3.
    TPU_V3 = 8;

    // Accelerator type is NVIDIA Tesla T4 Virtual Workstations.
    NVIDIA_TESLA_T4_VWS = 9;

    // Accelerator type is NVIDIA Tesla P100 Virtual Workstations.
    NVIDIA_TESLA_P100_VWS = 10;

    // Accelerator type is NVIDIA Tesla P4 Virtual Workstations.
    NVIDIA_TESLA_P4_VWS = 11;
  }

  // Accelerator model.
  AcceleratorType type = 1;

  // Count of cores of this accelerator.
  int64 core_count = 2;
}

// Represents a custom encryption key configuration that can be applied to
// a resource. This will encrypt all disks in Virtual Machine.
message EncryptionConfig {
  // The Cloud KMS resource identifier of the customer-managed encryption key
  // used to protect a resource, such as a disks. It has the following
  // format:
  // `projects/{PROJECT_ID}/locations/{REGION}/keyRings/{KEY_RING_NAME}/cryptoKeys/{KEY_NAME}`
  string kms_key = 1;
}

// A Local attached disk resource.
message LocalDisk {
  // Optional. A list of features to enable on the guest operating system.
  // Applicable only for bootable images.
  // Read [Enabling guest operating system
  // features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features)
  // to see a list of available options.
  // Guest OS features for boot disk.
  message RuntimeGuestOsFeature {
    // The ID of a supported feature. Read [Enabling guest operating system
    // features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features)
    // to see a list of available options.
    //
    // Valid values:
    //
    // * `FEATURE_TYPE_UNSPECIFIED`
    // * `MULTI_IP_SUBNET`
    // * `SECURE_BOOT`
    // * `UEFI_COMPATIBLE`
    // * `VIRTIO_SCSI_MULTIQUEUE`
    // * `WINDOWS`
    string type = 1;
  }

  // Optional. Output only. Specifies whether the disk will be auto-deleted when
  // the instance is deleted (but not when the disk is detached from the
  // instance).
  bool auto_delete = 1;

  // Optional. Output only. Indicates that this is a boot disk. The virtual
  // machine will use the first partition of the disk for its root filesystem.
  bool boot = 2;

  // Optional. Output only. Specifies a unique device name
  // of your choice that is reflected into the
  // `/dev/disk/by-id/google-*` tree of a Linux operating system running within
  // the instance. This name can be used to reference the device for mounting,
  // resizing, and so on, from within the instance.
  //
  // If not specified, the server chooses a default device name to apply to this
  // disk, in the form persistent-disk-x, where x is a number assigned by Google
  // Compute Engine. This field is only applicable for persistent disks.
  string device_name = 3;

  // Output only. Indicates a list of features to enable on the guest operating
  // system. Applicable only for bootable images. Read  Enabling guest operating
  // system features to see a list of available options.
  repeated RuntimeGuestOsFeature guest_os_features = 4;

  // Output only. A zero-based index to this disk, where 0 is reserved for the
  // boot disk. If you have many disks attached to an instance, each disk would
  // have a unique index number.
  int32 index = 5;

  // Specifies the disk interface to use for attaching this disk, which is
  // either SCSI or NVME. The default is SCSI. Persistent disks must always use
  // SCSI and the request will fail if you attempt to attach a persistent disk
  // in any other format than SCSI. Local SSDs can use either NVME or SCSI. For
  // performance characteristics of SCSI over NVMe, see Local SSD performance.
  // Valid values:
  //
  // * `NVME`
  // * `SCSI`
  string interface = 7;

  // Output only. Type of the resource. Always compute#attachedDisk for attached
  // disks.
  string kind = 8;

  // Output only. Any valid publicly visible licenses.
  repeated string licenses = 9;

  // The mode in which to attach this disk, either `READ_WRITE` or `READ_ONLY`.
  // If not specified, the default is to attach the disk in `READ_WRITE` mode.
  // Valid values:
  //
  // * `READ_ONLY`
  // * `READ_WRITE`
  string mode = 10;

  // Specifies a valid partial or full URL to an existing Persistent Disk
  // resource.
  string source = 11;

  // Specifies the type of the disk, either `SCRATCH` or `PERSISTENT`. If not
  // specified, the default is `PERSISTENT`.
  // Valid values:
  //
  // * `PERSISTENT`
  // * `SCRATCH`
  string type = 12;
}

// Input only. Specifies the parameters for a new disk that will be created
// alongside the new instance. Use initialization parameters to create boot
// disks or local SSDs attached to the new runtime.
// This property is mutually exclusive with the source property; you can only
// define one or the other, but not both.
message LocalDiskInitializeParams {
  // Possible disk types.
  enum DiskType {
    // Disk type not set.
    DISK_TYPE_UNSPECIFIED = 0;

    // Standard persistent disk type.
    PD_STANDARD = 1;

    // SSD persistent disk type.
    PD_SSD = 2;

    // Balanced persistent disk type.
    PD_BALANCED = 3;

    // Extreme persistent disk type.
    PD_EXTREME = 4;
  }

  // Optional. Provide this property when creating the disk.
  string description = 1;

  // Optional. Specifies the disk name. If not specified, the default is to use
  // the name of the instance. If the disk with the instance name exists already
  // in the given zone/region, a new name will be automatically generated.
  string disk_name = 2;

  // Optional. Specifies the size of the disk in base-2 GB. If not specified,
  // the disk will be the same size as the image (usually 10GB). If specified,
  // the size must be equal to or larger than 10GB. Default 100 GB.
  int64 disk_size_gb = 3;

  // Optional. Labels to apply to this disk. These can be later modified by the
  // disks.setLabels method. This field is only applicable for persistent disks.
  map<string, string> labels = 5;
}

// Specifies the login configuration for Runtime
message RuntimeAccessConfig {
  // Possible ways to access runtime. Authentication mode.
  // Currently supports: Single User only.
  enum RuntimeAccessType {
    // Unspecified access.
    RUNTIME_ACCESS_TYPE_UNSPECIFIED = 0;

    // Single user login.
    SINGLE_USER = 1;

    // Service Account mode.
    // In Service Account mode, Runtime creator will specify a SA that exists
    // in the consumer project. Using Runtime Service Account field.
    // Users accessing the Runtime need ActAs (Service Account User) permission.
    SERVICE_ACCOUNT = 2;
  }

  // The type of access mode this instance.
  RuntimeAccessType access_type = 1;

  // The owner of this runtime after creation. Format: `alias@example.com`
  // Currently supports one owner only.
  string runtime_owner = 2;

  // Output only. The proxy endpoint that is used to access the runtime.
  string proxy_uri = 3;
}

// Specifies the selection and configuration of software inside the runtime.
// The properties to set on runtime.
// Properties keys are specified in `key:value` format, for example:
//
// * `idle_shutdown: true`
// * `idle_shutdown_timeout: 180`
// * `enable_health_monitoring: true`
message RuntimeSoftwareConfig {
  // Behavior for the post startup script.
  enum PostStartupScriptBehavior {
    // Unspecified post startup script behavior. Will run only once at creation.
    POST_STARTUP_SCRIPT_BEHAVIOR_UNSPECIFIED = 0;

    // Runs the post startup script provided during creation at every start.
    RUN_EVERY_START = 1;

    // Downloads and runs the provided post startup script at every start.
    DOWNLOAD_AND_RUN_EVERY_START = 2;
  }

  // Cron expression in UTC timezone, used to schedule instance auto upgrade.
  // Please follow the [cron format](https://en.wikipedia.org/wiki/Cron).
  string notebook_upgrade_schedule = 1;

  // Verifies core internal services are running.
  // Default: True
  optional bool enable_health_monitoring = 2;

  // Runtime will automatically shutdown after idle_shutdown_time.
  // Default: True
  optional bool idle_shutdown = 3;

  // Time in minutes to wait before shutting down runtime. Default: 180 minutes
  int32 idle_shutdown_timeout = 4;

  // Install Nvidia Driver automatically.
  // Default: True
  bool install_gpu_driver = 5;

  // Specify a custom Cloud Storage path where the GPU driver is stored.
  // If not specified, we'll automatically choose from official GPU drivers.
  string custom_gpu_driver_path = 6;

  // Path to a Bash script that automatically runs after a notebook instance
  // fully boots up. The path must be a URL or
  // Cloud Storage path (`gs://path-to-file/file-name`).
  string post_startup_script = 7;

  // Optional. Use a list of container images to use as Kernels in the notebook
  // instance.
  repeated ContainerImage kernels = 8;

  // Output only. Bool indicating whether an newer image is available in an
  // image family.
  optional bool upgradeable = 9;

  // Behavior for the post startup script.
  PostStartupScriptBehavior post_startup_script_behavior = 10;

  // Bool indicating whether JupyterLab terminal will be available or not.
  // Default: False
  optional bool disable_terminal = 11;

  // Output only. version of boot image such as M100, from release label of the
  // image.
  optional string version = 12;

  // Bool indicating whether mixer client should be disabled.
  // Default: False
  optional bool mixer_disabled = 13;
}

// Contains runtime daemon metrics, such as OS and kernels and sessions stats.
message RuntimeMetrics {
  // Output only. The system metrics.
  map<string, string> system_metrics = 1;
}

// A set of Shielded Instance options.
// See [Images using supported Shielded VM
// features](https://cloud.google.com/compute/docs/instances/modifying-shielded-vm).
// Not all combinations are valid.
message RuntimeShieldedInstanceConfig {
  // Defines whether the instance has Secure Boot enabled.
  //
  // Secure Boot helps ensure that the system only runs authentic software by
  // verifying the digital signature of all boot components, and halting the
  // boot process if signature verification fails. Disabled by default.
  bool enable_secure_boot = 1;

  // Defines whether the instance has the vTPM enabled. Enabled by default.
  bool enable_vtpm = 2;

  // Defines whether the instance has integrity monitoring enabled.
  //
  // Enables monitoring and attestation of the boot integrity of the instance.
  // The attestation is performed against the integrity policy baseline. This
  // baseline is initially derived from the implicitly trusted boot image when
  // the instance is created. Enabled by default.
  bool enable_integrity_monitoring = 3;
}

// Runtime using Virtual Machine for computing.
message VirtualMachine {
  // Output only. The user-friendly name of the Managed Compute Engine instance.
  string instance_name = 1;

  // Output only. The unique identifier of the Managed Compute Engine instance.
  string instance_id = 2;

  // Virtual Machine configuration settings.
  VirtualMachineConfig virtual_machine_config = 3;
}

// The config settings for virtual machine.
message VirtualMachineConfig {
  // Definition of the boot image used by the Runtime.
  // Used to facilitate runtime upgradeability.
  message BootImage {}

  // The type of vNIC driver.
  // Default should be UNSPECIFIED_NIC_TYPE.
  enum NicType {
    // No type specified.
    UNSPECIFIED_NIC_TYPE = 0;

    // VIRTIO
    VIRTIO_NET = 1;

    // GVNIC
    GVNIC = 2;
  }

  // Output only. The zone where the virtual machine is located.
  // If using regional request, the notebooks service will pick a location
  // in the corresponding runtime region.
  // On a get request, zone will always be present. Example:
  // * `us-central1-b`
  string zone = 1;

  // Required. The Compute Engine machine type used for runtimes.
  // Short name is valid. Examples:
  // * `n1-standard-2`
  // * `e2-standard-8`
  string machine_type = 2;

  // Optional. Use a list of container images to use as Kernels in the notebook
  // instance.
  repeated ContainerImage container_images = 3;

  // Required. Data disk option configuration settings.
  LocalDisk data_disk = 4;

  // Optional. Encryption settings for virtual machine data disk.
  EncryptionConfig encryption_config = 5;

  // Optional. Shielded VM Instance configuration settings.
  RuntimeShieldedInstanceConfig shielded_instance_config = 6;

  // Optional. The Compute Engine accelerator configuration for this runtime.
  RuntimeAcceleratorConfig accelerator_config = 7;

  // Optional. The Compute Engine network to be used for machine
  // communications. Cannot be specified with subnetwork. If neither
  // `network` nor `subnet` is specified, the "default" network of
  // the project is used, if it exists.
  //
  // A full URL or partial URI. Examples:
  //
  // * `https://www.googleapis.com/compute/v1/projects/[project_id]/global/networks/default`
  // * `projects/[project_id]/global/networks/default`
  //
  // Runtimes are managed resources inside Google Infrastructure.
  // Runtimes support the following network configurations:
  //
  // * Google Managed Network (Network & subnet are empty)
  // * Consumer Project VPC (network & subnet are required). Requires
  // configuring Private Service Access.
  // * Shared VPC (network & subnet are required). Requires configuring Private
  // Service Access.
  string network = 8;

  // Optional. The Compute Engine subnetwork to be used for machine
  // communications. Cannot be specified with network.
  //
  // A full URL or partial URI are valid. Examples:
  //
  // * `https://www.googleapis.com/compute/v1/projects/[project_id]/regions/us-east1/subnetworks/sub0`
  // * `projects/[project_id]/regions/us-east1/subnetworks/sub0`
  string subnet = 9;

  // Optional. If true, runtime will only have internal IP
  // addresses. By default, runtimes are not restricted to internal IP
  // addresses, and will have ephemeral external IP addresses assigned to each
  // vm. This `internal_ip_only` restriction can only be enabled for
  // subnetwork enabled networks, and all dependencies must be
  // configured to be accessible without external IP addresses.
  bool internal_ip_only = 10;

  // Optional. The Compute Engine tags to add to runtime (see [Tagging
  // instances](https://cloud.google.com/compute/docs/label-or-tag-resources#tags)).
  repeated string tags = 13;

  // Output only. The Compute Engine guest attributes. (see
  // [Project and instance
  // guest
  // attributes](https://cloud.google.com/compute/docs/storing-retrieving-metadata#guest_attributes)).
  map<string, string> guest_attributes = 14;

  // Optional. The Compute Engine metadata entries to add to virtual machine.
  // (see [Project and instance
  // metadata](https://cloud.google.com/compute/docs/storing-retrieving-metadata#project_and_instance_metadata)).
  map<string, string> metadata = 15;

  // Optional. The labels to associate with this runtime.
  // Label **keys** must contain 1 to 63 characters, and must conform to
  // [RFC 1035](https://www.ietf.org/rfc/rfc1035.txt).
  // Label **values** may be empty, but, if present, must contain 1 to 63
  // characters, and must conform to [RFC
  // 1035](https://www.ietf.org/rfc/rfc1035.txt). No more than 32 labels can be
  // associated with a cluster.
  map<string, string> labels = 16;

  // Optional. The type of vNIC to be used on this interface. This may be gVNIC
  // or VirtioNet.
  NicType nic_type = 17;

  // Optional. Reserved IP Range name is used for VPC Peering.
  // The subnetwork allocation will use the range *name* if it's assigned.
  //
  // Example: managed-notebooks-range-c
  //
  //     PEERING_RANGE_NAME_3=managed-notebooks-range-c
  //     gcloud compute addresses create $PEERING_RANGE_NAME_3 \
  //       --global \
  //       --prefix-length=24 \
  //       --description="Google Cloud Managed Notebooks Range 24 c" \
  //       --network=$NETWORK \
  //       --addresses=192.168.0.0 \
  //       --purpose=VPC_PEERING
  //
  // Field value will be: `managed-notebooks-range-c`
  string reserved_ip_range = 18;

  // Optional. Boot image metadata used for runtime upgradeability.
  BootImage boot_image = 19;
}

// The description a notebook execution workload.
message ExecutionTemplate {
  // Definition of a hardware accelerator. Note that not all combinations
  // of `type` and `core_count` are valid. See [GPUs on
  // Compute Engine](https://cloud.google.com/compute/docs/gpus) to find a valid
  // combination. TPUs are not supported.
  message SchedulerAcceleratorConfig {
    // Type of this accelerator.
    SchedulerAcceleratorType type = 1;

    // Count of cores of this accelerator.
    int64 core_count = 2;
  }

  // Parameters used in Dataproc JobType executions.
  message DataprocParameters {
    // URI for cluster used to run Dataproc execution.
    // Format: `projects/{PROJECT_ID}/regions/{REGION}/clusters/{CLUSTER_NAME}`
    string cluster = 1;
  }

  // Parameters used in Vertex AI JobType executions.
  message VertexAIParameters {
    // The full name of the Compute Engine
    // [network](https://cloud.google.com/compute/docs/networks-and-firewalls#networks)
    // to which the Job should be peered. For example,
    // `projects/12345/global/networks/myVPC`.
    // [Format](https://cloud.google.com/compute/docs/reference/rest/v1/networks/insert)
    // is of the form `projects/{project}/global/networks/{network}`.
    // Where `{project}` is a project number, as in `12345`, and `{network}` is
    // a network name.
    //
    // Private services access must already be configured for the network. If
    // left unspecified, the job is not peered with any network.
    string network = 1;

    // Environment variables.
    // At most 100 environment variables can be specified and unique.
    // Example: `GCP_BUCKET=gs://my-bucket/samples/`
    map<string, string> env = 2;
  }

  // Required. Specifies the machine types, the number of replicas for workers
  // and parameter servers.
  enum ScaleTier {
    // Unspecified Scale Tier.
    SCALE_TIER_UNSPECIFIED = 0;

    // A single worker instance. This tier is suitable for learning how to use
    // Cloud ML, and for experimenting with new models using small datasets.
    BASIC = 1;

    // Many workers and a few parameter servers.
    STANDARD_1 = 2;

    // A large number of workers with many parameter servers.
    PREMIUM_1 = 3;

    // A single worker instance with a K80 GPU.
    BASIC_GPU = 4;

    // A single worker instance with a Cloud TPU.
    BASIC_TPU = 5;

    // The CUSTOM tier is not a set tier, but rather enables you to use your
    // own cluster specification. When you use this tier, set values to
    // configure your processing cluster according to these guidelines:
    //
    // *   You _must_ set `ExecutionTemplate.masterType` to specify the type
    //     of machine to use for your master node. This is the only required
    //     setting.
    CUSTOM = 6;
  }

  // Hardware accelerator types for AI Platform Training jobs.
  enum SchedulerAcceleratorType {
    // Unspecified accelerator type. Default to no GPU.
    SCHEDULER_ACCELERATOR_TYPE_UNSPECIFIED = 0;

    // Nvidia Tesla K80 GPU.
    NVIDIA_TESLA_K80 = 1;

    // Nvidia Tesla P100 GPU.
    NVIDIA_TESLA_P100 = 2;

    // Nvidia Tesla V100 GPU.
    NVIDIA_TESLA_V100 = 3;

    // Nvidia Tesla P4 GPU.
    NVIDIA_TESLA_P4 = 4;

    // Nvidia Tesla T4 GPU.
    NVIDIA_TESLA_T4 = 5;

    // Nvidia Tesla A100 GPU.
    NVIDIA_TESLA_A100 = 10;

    // TPU v2.
    TPU_V2 = 6;

    // TPU v3.
    TPU_V3 = 7;
  }

  // The backend used for this execution.
  enum JobType {
    // No type specified.
    JOB_TYPE_UNSPECIFIED = 0;

    // Custom Job in `aiplatform.googleapis.com`.
    // Default value for an execution.
    VERTEX_AI = 1;

    // Run execution on a cluster with Dataproc as a job.
    // https://cloud.google.com/dataproc/docs/reference/rest/v1/projects.regions.jobs
    DATAPROC = 2;
  }

  // Required. Scale tier of the hardware used for notebook execution.
  // DEPRECATED Will be discontinued. As right now only CUSTOM is supported.
  ScaleTier scale_tier = 1;

  // Specifies the type of virtual machine to use for your training
  // job's master worker. You must specify this field when `scaleTier` is set to
  // `CUSTOM`.
  //
  // You can use certain Compute Engine machine types directly in this field.
  // The following types are supported:
  //
  // - `n1-standard-4`
  // - `n1-standard-8`
  // - `n1-standard-16`
  // - `n1-standard-32`
  // - `n1-standard-64`
  // - `n1-standard-96`
  // - `n1-highmem-2`
  // - `n1-highmem-4`
  // - `n1-highmem-8`
  // - `n1-highmem-16`
  // - `n1-highmem-32`
  // - `n1-highmem-64`
  // - `n1-highmem-96`
  // - `n1-highcpu-16`
  // - `n1-highcpu-32`
  // - `n1-highcpu-64`
  // - `n1-highcpu-96`
  //
  //
  // Alternatively, you can use the following legacy machine types:
  //
  // - `standard`
  // - `large_model`
  // - `complex_model_s`
  // - `complex_model_m`
  // - `complex_model_l`
  // - `standard_gpu`
  // - `complex_model_m_gpu`
  // - `complex_model_l_gpu`
  // - `standard_p100`
  // - `complex_model_m_p100`
  // - `standard_v100`
  // - `large_model_v100`
  // - `complex_model_m_v100`
  // - `complex_model_l_v100`
  //
  //
  // Finally, if you want to use a TPU for training, specify `cloud_tpu` in this
  // field. Learn more about the [special configuration options for training
  // with
  // TPU](https://cloud.google.com/ai-platform/training/docs/using-tpus#configuring_a_custom_tpu_machine).
  string master_type = 2;

  // Configuration (count and accelerator type) for hardware running notebook
  // execution.
  SchedulerAcceleratorConfig accelerator_config = 3;

  // Labels for execution.
  // If execution is scheduled, a field included will be 'nbs-scheduled'.
  // Otherwise, it is an immediate execution, and an included field will be
  // 'nbs-immediate'. Use fields to efficiently index between various types of
  // executions.
  map<string, string> labels = 4;

  // Path to the notebook file to execute.
  // Must be in a Google Cloud Storage bucket.
  // Format: `gs://{bucket_name}/{folder}/{notebook_file_name}`
  // Ex: `gs://notebook_user/scheduled_notebooks/sentiment_notebook.ipynb`
  string input_notebook_file = 5;

  // Container Image URI to a DLVM
  // Example: 'gcr.io/deeplearning-platform-release/base-cu100'
  // More examples can be found at:
  // https://cloud.google.com/ai-platform/deep-learning-containers/docs/choosing-container
  string container_image_uri = 6;

  // Path to the notebook folder to write to.
  // Must be in a Google Cloud Storage bucket path.
  // Format: `gs://{bucket_name}/{folder}`
  // Ex: `gs://notebook_user/scheduled_notebooks`
  string output_notebook_folder = 7;

  // Parameters to be overridden in the notebook during execution.
  // Ref https://papermill.readthedocs.io/en/latest/usage-parameterize.html on
  // how to specifying parameters in the input notebook and pass them here
  // in an YAML file.
  // Ex: `gs://notebook_user/scheduled_notebooks/sentiment_notebook_params.yaml`
  string params_yaml_file = 8;

  // Parameters used within the 'input_notebook_file' notebook.
  string parameters = 9;

  // The email address of a service account to use when running the execution.
  // You must have the `iam.serviceAccounts.actAs` permission for the specified
  // service account.
  string service_account = 10;

  // The type of Job to be used on this execution.
  JobType job_type = 11;

  // Parameters for an execution type.
  // NOTE: There are currently no extra parameters for VertexAI jobs.
  oneof job_parameters {
    // Parameters used in Dataproc JobType executions.
    DataprocParameters dataproc_parameters = 12;

    // Parameters used in Vertex AI JobType executions.
    VertexAIParameters vertex_ai_parameters = 13;
  }

  // Name of the kernel spec to use. This must be specified if the
  // kernel spec name on the execution target does not match the name in the
  // input notebook file.
  string kernel_spec = 14;

  // The name of a Vertex AI [Tensorboard] resource to which this execution
  // will upload Tensorboard logs.
  // Format:
  // `projects/{project}/locations/{location}/tensorboards/{tensorboard}`
  string tensorboard = 15;
}

// The definition of a single executed notebook.
message Execution {
  // Enum description of the state of the underlying AIP job.
  enum State {
    // The job state is unspecified.
    STATE_UNSPECIFIED = 0;

    // The job has been just created and processing has not yet begun.
    QUEUED = 1;

    // The service is preparing to execution the job.
    PREPARING = 2;

    // The job is in progress.
    RUNNING = 3;

    // The job completed successfully.
    SUCCEEDED = 4;

    // The job failed.
    // `error_message` should contain the details of the failure.
    FAILED = 5;

    // The job is being cancelled.
    // `error_message` should describe the reason for the cancellation.
    CANCELLING = 6;

    // The job has been cancelled.
    // `error_message` should describe the reason for the cancellation.
    CANCELLED = 7;

    // The job has become expired (relevant to Vertex AI jobs)
    // https://cloud.google.com/vertex-ai/docs/reference/rest/v1/JobState
    EXPIRED = 9;

    // The Execution is being created.
    INITIALIZING = 10;
  }

  // execute metadata including name, hardware spec, region, labels, etc.
  ExecutionTemplate execution_template = 1;

  // Output only. The resource name of the execute. Format:
  // `projects/{project_id}/locations/{location}/executions/{execution_id}`
  string name = 2;

  // Output only. Name used for UI purposes.
  // Name can only contain alphanumeric characters and underscores '_'.
  string display_name = 3;

  // A brief description of this execution.
  string description = 4;

  // Output only. Time the Execution was instantiated.
  google.protobuf.Timestamp create_time = 5;

  // Output only. Time the Execution was last updated.
  google.protobuf.Timestamp update_time = 6;

  // Output only. State of the underlying AI Platform job.
  State state = 7;

  // Output notebook file generated by this execution
  string output_notebook_file = 8;

  // Output only. The URI of the external job used to execute the notebook.
  string job_uri = 9;
}

// Reservation Affinity for consuming Zonal reservation.
message ReservationAffinity {
  // Indicates whether to consume capacity from an reservation or not.
  enum Type {
    // Default type.
    TYPE_UNSPECIFIED = 0;

    // Do not consume from any allocated capacity.
    NO_RESERVATION = 1;

    // Consume any reservation available.
    ANY_RESERVATION = 2;

    // Must consume from a specific reservation. Must specify key value fields
    // for specifying the reservations.
    SPECIFIC_RESERVATION = 3;
  }

  // Optional. Type of reservation to consume
  Type consume_reservation_type = 1;

  // Optional. Corresponds to the label key of reservation resource.
  string key = 2;

  // Optional. Corresponds to the label values of reservation resource.
  repeated string values = 3;
}

// The definition of a notebook instance.
message Instance {
  // Definition of a hardware accelerator. Note that not all combinations
  // of `type` and `core_count` are valid. See [GPUs on Compute
  // Engine](https://cloud.google.com/compute/docs/gpus/#gpus-list) to find a
  // valid combination. TPUs are not supported.
  message AcceleratorConfig {
    // Type of this accelerator.
    AcceleratorType type = 1;

    // Count of cores of this accelerator.
    int64 core_count = 2;
  }

  // An instance-attached disk resource.
  message Disk {
    // Guest OS features for boot disk.
    message GuestOsFeature {
      // The ID of a supported feature. Read  Enabling guest operating system
      // features to see a list of available options.
      // Valid values:
      //
      // * `FEATURE_TYPE_UNSPECIFIED`
      // * `MULTI_IP_SUBNET`
      // * `SECURE_BOOT`
      // * `UEFI_COMPATIBLE`
      // * `VIRTIO_SCSI_MULTIQUEUE`
      // * `WINDOWS`
      string type = 1;
    }

    // Indicates whether the disk will be auto-deleted when the instance is
    // deleted (but not when the disk is detached from the instance).
    bool auto_delete = 1;

    // Indicates that this is a boot disk. The virtual machine will use the
    // first partition of the disk for its root filesystem.
    bool boot = 2;

    // Indicates a unique device name of your choice that is reflected into the
    // `/dev/disk/by-id/google-*` tree of a Linux operating system running
    // within the instance. This name can be used to reference the device for
    // mounting, resizing, and so on, from within the instance.
    //
    // If not specified, the server chooses a default device name to apply to
    // this disk, in the form persistent-disk-x, where x is a number assigned by
    // Google Compute Engine.This field is only applicable for persistent disks.
    string device_name = 3;

    // Indicates the size of the disk in base-2 GB.
    int64 disk_size_gb = 4;

    // Indicates a list of features to enable on the guest operating system.
    // Applicable only for bootable images. Read  Enabling guest operating
    // system features to see a list of available options.
    repeated GuestOsFeature guest_os_features = 5;

    // A zero-based index to this disk, where 0 is reserved for the
    // boot disk. If you have many disks attached to an instance, each disk
    // would have a unique index number.
    int64 index = 6;

    // Indicates the disk interface to use for attaching this disk, which is
    // either SCSI or NVME. The default is SCSI. Persistent disks must always
    // use SCSI and the request will fail if you attempt to attach a persistent
    // disk in any other format than SCSI. Local SSDs can use either NVME or
    // SCSI. For performance characteristics of SCSI over NVMe, see Local SSD
    // performance.
    // Valid values:
    //
    // * `NVME`
    // * `SCSI`
    string interface = 7;

    // Type of the resource. Always compute#attachedDisk for attached
    // disks.
    string kind = 8;

    // A list of publicly visible licenses. Reserved for Google's use.
    // A License represents billing and aggregate usage data for public
    // and marketplace images.
    repeated string licenses = 9;

    // The mode in which to attach this disk, either `READ_WRITE` or
    // `READ_ONLY`. If not specified, the default is to attach the disk in
    // `READ_WRITE` mode. Valid values:
    //
    // * `READ_ONLY`
    // * `READ_WRITE`
    string mode = 10;

    // Indicates a valid partial or full URL to an existing Persistent Disk
    // resource.
    string source = 11;

    // Indicates the type of the disk, either `SCRATCH` or `PERSISTENT`.
    // Valid values:
    //
    // * `PERSISTENT`
    // * `SCRATCH`
    string type = 12;
  }

  // A set of Shielded Instance options.
  // See [Images using supported Shielded VM
  // features](https://cloud.google.com/compute/docs/instances/modifying-shielded-vm).
  // Not all combinations are valid.
  message ShieldedInstanceConfig {
    // Defines whether the instance has Secure Boot enabled.
    //
    // Secure Boot helps ensure that the system only runs authentic software by
    // verifying the digital signature of all boot components, and halting the
    // boot process if signature verification fails. Disabled by default.
    bool enable_secure_boot = 1;

    // Defines whether the instance has the vTPM enabled. Enabled by default.
    bool enable_vtpm = 2;

    // Defines whether the instance has integrity monitoring enabled.
    //
    // Enables monitoring and attestation of the boot integrity of the instance.
    // The attestation is performed against the integrity policy baseline. This
    // baseline is initially derived from the implicitly trusted boot image when
    // the instance is created. Enabled by default.
    bool enable_integrity_monitoring = 3;
  }

  // The entry of VM image upgrade history.
  message UpgradeHistoryEntry {
    // The definition of the states of this upgrade history entry.
    enum State {
      // State is not specified.
      STATE_UNSPECIFIED = 0;

      // The instance upgrade is started.
      STARTED = 1;

      // The instance upgrade is succeeded.
      SUCCEEDED = 2;

      // The instance upgrade is failed.
      FAILED = 3;
    }

    // The definition of operations of this upgrade history entry.
    enum Action {
      // Operation is not specified.
      ACTION_UNSPECIFIED = 0;

      // Upgrade.
      UPGRADE = 1;

      // Rollback.
      ROLLBACK = 2;
    }

    // The snapshot of the boot disk of this notebook instance before upgrade.
    string snapshot = 1;

    // The VM image before this instance upgrade.
    string vm_image = 2;

    // The container image before this instance upgrade.
    string container_image = 3;

    // The framework of this notebook instance.
    string framework = 4;

    // The version of the notebook instance before this upgrade.
    string version = 5;

    // The state of this instance upgrade history entry.
    State state = 6;

    // The time that this instance upgrade history entry is created.
    google.protobuf.Timestamp create_time = 7;

    // Target VM Image. Format: `ainotebooks-vm/project/image-name/name`.
    string target_image = 8;

    // Action. Rolloback or Upgrade.
    Action action = 9;

    // Target VM Version, like m63.
    string target_version = 10;
  }

  // Definition of the types of hardware accelerators that can be used on this
  // instance.
  enum AcceleratorType {
    // Accelerator type is not specified.
    ACCELERATOR_TYPE_UNSPECIFIED = 0;

    // Accelerator type is Nvidia Tesla K80.
    NVIDIA_TESLA_K80 = 1;

    // Accelerator type is Nvidia Tesla P100.
    NVIDIA_TESLA_P100 = 2;

    // Accelerator type is Nvidia Tesla V100.
    NVIDIA_TESLA_V100 = 3;

    // Accelerator type is Nvidia Tesla P4.
    NVIDIA_TESLA_P4 = 4;

    // Accelerator type is Nvidia Tesla T4.
    NVIDIA_TESLA_T4 = 5;

    // Accelerator type is Nvidia Tesla A100.
    NVIDIA_TESLA_A100 = 11;

    // Accelerator type is NVIDIA Tesla T4 Virtual Workstations.
    NVIDIA_TESLA_T4_VWS = 8;

    // Accelerator type is NVIDIA Tesla P100 Virtual Workstations.
    NVIDIA_TESLA_P100_VWS = 9;

    // Accelerator type is NVIDIA Tesla P4 Virtual Workstations.
    NVIDIA_TESLA_P4_VWS = 10;

    // (Coming soon) Accelerator type is TPU V2.
    TPU_V2 = 6;

    // (Coming soon) Accelerator type is TPU V3.
    TPU_V3 = 7;
  }

  // The definition of the states of this instance.
  enum State {
    // State is not specified.
    STATE_UNSPECIFIED = 0;

    // The control logic is starting the instance.
    STARTING = 1;

    // The control logic is installing required frameworks and registering the
    // instance with notebook proxy
    PROVISIONING = 2;

    // The instance is running.
    ACTIVE = 3;

    // The control logic is stopping the instance.
    STOPPING = 4;

    // The instance is stopped.
    STOPPED = 5;

    // The instance is deleted.
    DELETED = 6;

    // The instance is upgrading.
    UPGRADING = 7;

    // The instance is being created.
    INITIALIZING = 8;

    // The instance is getting registered.
    REGISTERING = 9;

    // The instance is suspending.
    SUSPENDING = 10;

    // The instance is suspended.
    SUSPENDED = 11;
  }

  // Possible disk types for notebook instances.
  enum DiskType {
    // Disk type not set.
    DISK_TYPE_UNSPECIFIED = 0;

    // Standard persistent disk type.
    PD_STANDARD = 1;

    // SSD persistent disk type.
    PD_SSD = 2;

    // Balanced persistent disk type.
    PD_BALANCED = 3;

    // Extreme persistent disk type.
    PD_EXTREME = 4;
  }

  // Definition of the disk encryption options.
  enum DiskEncryption {
    // Disk encryption is not specified.
    DISK_ENCRYPTION_UNSPECIFIED = 0;

    // Use Google managed encryption keys to encrypt the boot disk.
    GMEK = 1;

    // Use customer managed encryption keys to encrypt the boot disk.
    CMEK = 2;
  }

  // The type of vNIC driver.
  // Default should be UNSPECIFIED_NIC_TYPE.
  enum NicType {
    // No type specified.
    UNSPECIFIED_NIC_TYPE = 0;

    // VIRTIO
    VIRTIO_NET = 1;

    // GVNIC
    GVNIC = 2;
  }

  // Output only. The name of this notebook instance. Format:
  // `projects/{project_id}/locations/{location}/instances/{instance_id}`
  string name = 1;

  // Type of the environment; can be one of VM image, or container image.
  oneof environment {
    // Use a Compute Engine VM image to start the notebook instance.
    VmImage vm_image = 2;

    // Use a container image to start the notebook instance.
    ContainerImage container_image = 3;
  }

  // Path to a Bash script that automatically runs after a notebook instance
  // fully boots up. The path must be a URL or
  // Cloud Storage path (`gs://path-to-file/file-name`).
  string post_startup_script = 4;

  // Output only. The proxy endpoint that is used to access the Jupyter
  // notebook.
  string proxy_uri = 5;

  // The service account on this instance, giving access to other Google
  // Cloud services.
  // You can use any service account within the same project, but you
  // must have the service account user permission to use the instance.
  //
  // If not specified, the [Compute Engine default service
  // account](https://cloud.google.com/compute/docs/access/service-accounts#default_service_account)
  // is used.
  string service_account = 7;

  // Optional. The URIs of service account scopes to be included in
  // Compute Engine instances.
  //
  // If not specified, the following
  // [scopes](https://cloud.google.com/compute/docs/access/service-accounts#accesscopesiam)
  // are defined:
  //  - https://www.googleapis.com/auth/cloud-platform
  //  - https://www.googleapis.com/auth/userinfo.email
  // If not using default scopes, you need at least:
  //    https://www.googleapis.com/auth/compute
  repeated string service_account_scopes = 31;

  // Required. The [Compute Engine machine
  // type](https://cloud.google.com/compute/docs/machine-types) of this
  // instance.
  string machine_type = 8;

  // The hardware accelerator used on this instance. If you use
  // accelerators, make sure that your configuration has
  // [enough vCPUs and memory to support the `machine_type` you have
  // selected](https://cloud.google.com/compute/docs/gpus/#gpus-list).
  AcceleratorConfig accelerator_config = 9;

  // Output only. The state of this instance.
  State state = 10;

  // Whether the end user authorizes Google Cloud to install GPU driver
  // on this instance.
  // If this field is empty or set to false, the GPU driver won't be installed.
  // Only applicable to instances with GPUs.
  bool install_gpu_driver = 11;

  // Specify a custom Cloud Storage path where the GPU driver is stored.
  // If not specified, we'll automatically choose from official GPU drivers.
  string custom_gpu_driver_path = 12;

  // Output only. Attached disks to notebook instance.
  repeated Disk disks = 28;

  // Optional. Shielded VM configuration.
  // [Images using supported Shielded VM
  // features](https://cloud.google.com/compute/docs/instances/modifying-shielded-vm).
  ShieldedInstanceConfig shielded_instance_config = 30;

  // If true, no external IP will be assigned to this instance.
  bool no_public_ip = 17;

  // If true, the notebook instance will not register with the proxy.
  bool no_proxy_access = 18;

  // The name of the VPC that this instance is in.
  // Format:
  // `projects/{project_id}/global/networks/{network_id}`
  string network = 19;

  // The name of the subnet that this instance is in.
  // Format:
  // `projects/{project_id}/regions/{region}/subnetworks/{subnetwork_id}`
  string subnet = 20;

  // Labels to apply to this instance.
  // These can be later modified by the setLabels method.
  map<string, string> labels = 21;

  // Custom metadata to apply to this instance.
  map<string, string> metadata = 22;

  // Optional. The Compute Engine tags to add to runtime (see [Tagging
  // instances](https://cloud.google.com/compute/docs/label-or-tag-resources#tags)).
  repeated string tags = 32;

  // The upgrade history of this instance.
  repeated UpgradeHistoryEntry upgrade_history = 29;

  // Optional. The type of vNIC to be used on this interface. This may be gVNIC
  // or VirtioNet.
  NicType nic_type = 33;

  // Optional. The optional reservation affinity. Setting this field will apply
  // the specified [Zonal Compute
  // Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources)
  // to this notebook instance.
  ReservationAffinity reservation_affinity = 34;

  // Output only. Email address of entity that sent original CreateInstance
  // request.
  string creator = 36;

  // Optional. Flag to enable ip forwarding or not, default false/off.
  // https://cloud.google.com/vpc/docs/using-routes#canipforward
  bool can_ip_forward = 39;

  // Output only. Instance creation time.
  google.protobuf.Timestamp create_time = 23;

  // Output only. Instance update time.
  google.protobuf.Timestamp update_time = 24;
}

// The definition of a schedule.
message Schedule {
  // State of the job.
  enum State {
    // Unspecified state.
    STATE_UNSPECIFIED = 0;

    // The job is executing normally.
    ENABLED = 1;

    // The job is paused by the user. It will not execute. A user can
    // intentionally pause the job using
    // [PauseJobRequest][].
    PAUSED = 2;

    // The job is disabled by the system due to error. The user
    // cannot directly set a job to be disabled.
    DISABLED = 3;

    // The job state resulting from a failed [CloudScheduler.UpdateJob][]
    // operation. To recover a job from this state, retry
    // [CloudScheduler.UpdateJob][] until a successful response is received.
    UPDATE_FAILED = 4;

    // The schedule resource is being created.
    INITIALIZING = 5;

    // The schedule resource is being deleted.
    DELETING = 6;
  }

  // Output only. The name of this schedule. Format:
  // `projects/{project_id}/locations/{location}/schedules/{schedule_id}`
  string name = 1;

  // Output only. Display name used for UI purposes.
  // Name can only contain alphanumeric characters, hyphens `-`,
  // and underscores `_`.
  string display_name = 2;

  // A brief description of this environment.
  string description = 3;

  State state = 4;

  // Cron-tab formatted schedule by which the job will execute.
  // Format: minute, hour, day of month, month, day of week,
  // e.g. `0 0 * * WED` = every Wednesday
  // More examples: https://crontab.guru/examples.html
  string cron_schedule = 5;

  // Timezone on which the cron_schedule.
  // The value of this field must be a time zone name from the tz database.
  // TZ Database: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
  //
  // Note that some time zones include a provision for daylight savings time.
  // The rules for daylight saving time are determined by the chosen tz.
  // For UTC use the string "utc". If a time zone is not specified,
  // the default will be in UTC (also known as GMT).
  string time_zone = 6;

  // Output only. Time the schedule was created.
  google.protobuf.Timestamp create_time = 7;

  // Output only. Time the schedule was last updated.
  google.protobuf.Timestamp update_time = 8;

  // Notebook Execution Template corresponding to this schedule.
  ExecutionTemplate execution_template = 9;

  // Output only. The most recent execution names triggered from this schedule
  // and their corresponding states.
  repeated Execution recent_executions = 10;
}

// The data within all Runtime events.
message RuntimeEventData {
  // Optional. The Runtime event payload. Unset for deletion events.
  optional Runtime payload = 1;
}

// The data within all Execution events.
message ExecutionEventData {
  // Optional. The Execution event payload. Unset for deletion events.
  optional Execution payload = 1;
}

// The data within all Instance events.
message InstanceEventData {
  // Optional. The Instance event payload. Unset for deletion events.
  optional Instance payload = 1;
}

// The data within all Schedule events.
message ScheduleEventData {
  // Optional. The Schedule event payload. Unset for deletion events.
  optional Schedule payload = 1;
}

// The data within all Environment events.
message EnvironmentEventData {
  // Optional. The Environment event payload. Unset for deletion events.
  optional Environment payload = 1;
}