text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union, overload
  from ... import _utilities
  from ._enums import *
  
  __all__ = [
      'AcceleratorConfigArgs',
      'BindingArgs',
      'ContainerImageArgs',
      'DataprocParametersArgs',
      'EncryptionConfigArgs',
      'ExecutionTemplateArgs',
      'ExprArgs',
      'LocalDiskInitializeParamsArgs',
      'LocalDiskArgs',
      'ReservationAffinityArgs',
      'RuntimeAcceleratorConfigArgs',
      'RuntimeAccessConfigArgs',
      'RuntimeShieldedInstanceConfigArgs',
      'RuntimeSoftwareConfigArgs',
      'SchedulerAcceleratorConfigArgs',
      'ShieldedInstanceConfigArgs',
      'UpgradeHistoryEntryArgs',
      'VertexAIParametersArgs',
      'VirtualMachineConfigArgs',
      'VirtualMachineArgs',
      'VmImageArgs',
  ]
  
  @pulumi.input_type
  class AcceleratorConfigArgs:
      def __init__(__self__, *,
                   core_count: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input['AcceleratorConfigType']] = None):
          """
          Definition of a hardware accelerator. Note that not all combinations of `type` and `core_count` are valid. Check [GPUs on Compute Engine](/compute/docs/gpus/#gpus-list) to find a valid combination. TPUs are not supported.
          :param pulumi.Input[str] core_count: Count of cores of this accelerator.
          :param pulumi.Input['AcceleratorConfigType'] type: Type of this accelerator.
          """
          if core_count is not None:
              pulumi.set(__self__, "core_count", core_count)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="coreCount")
      def core_count(self) -> Optional[pulumi.Input[str]]:
          """
          Count of cores of this accelerator.
          """
          return pulumi.get(self, "core_count")
  
      @core_count.setter
      def core_count(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "core_count", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input['AcceleratorConfigType']]:
          """
          Type of this accelerator.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input['AcceleratorConfigType']]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class BindingArgs:
      def __init__(__self__, *,
                   condition: Optional[pulumi.Input['ExprArgs']] = None,
                   members: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   role: Optional[pulumi.Input[str]] = None):
          """
          Associates `members`, or principals, with a `role`.
          :param pulumi.Input['ExprArgs'] condition: The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
          :param pulumi.Input[Sequence[pulumi.Input[str]]] members: Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. 
          :param pulumi.Input[str] role: Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
          """
          if condition is not None:
              pulumi.set(__self__, "condition", condition)
          if members is not None:
              pulumi.set(__self__, "members", members)
          if role is not None:
              pulumi.set(__self__, "role", role)
  
      @property
      @pulumi.getter
      def condition(self) -> Optional[pulumi.Input['ExprArgs']]:
          """
          The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
          """
          return pulumi.get(self, "condition")
  
      @condition.setter
      def condition(self, value: Optional[pulumi.Input['ExprArgs']]):
          pulumi.set(self, "condition", value)
  
      @property
      @pulumi.getter
      def members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. 
          """
          return pulumi.get(self, "members")
  
      @members.setter
      def members(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "members", value)
  
      @property
      @pulumi.getter
      def role(self) -> Optional[pulumi.Input[str]]:
          """
          Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "role", value)
  
  
  @pulumi.input_type
  class ContainerImageArgs:
      def __init__(__self__, *,
                   repository: pulumi.Input[str],
                   tag: Optional[pulumi.Input[str]] = None):
          """
          Definition of a container image for starting a notebook instance with the environment installed in a container.
          :param pulumi.Input[str] repository: The path to the container image repository. For example: `gcr.io/{project_id}/{image_name}`
          :param pulumi.Input[str] tag: The tag of the container image. If not specified, this defaults to the latest tag.
          """
          pulumi.set(__self__, "repository", repository)
          if tag is not None:
              pulumi.set(__self__, "tag", tag)
  
      @property
      @pulumi.getter
      def repository(self) -> pulumi.Input[str]:
          """
          The path to the container image repository. For example: `gcr.io/{project_id}/{image_name}`
          """
          return pulumi.get(self, "repository")
  
      @repository.setter
      def repository(self, value: pulumi.Input[str]):
          pulumi.set(self, "repository", value)
  
      @property
      @pulumi.getter
      def tag(self) -> Optional[pulumi.Input[str]]:
          """
          The tag of the container image. If not specified, this defaults to the latest tag.
          """
          return pulumi.get(self, "tag")
  
      @tag.setter
      def tag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "tag", value)
  
  
  @pulumi.input_type
  class DataprocParametersArgs:
      def __init__(__self__, *,
                   cluster: Optional[pulumi.Input[str]] = None):
          """
          Parameters used in Dataproc JobType executions.
          :param pulumi.Input[str] cluster: URI for cluster used to run Dataproc execution. Format: `projects/{PROJECT_ID}/regions/{REGION}/clusters/{CLUSTER_NAME}`
          """
          if cluster is not None:
              pulumi.set(__self__, "cluster", cluster)
  
      @property
      @pulumi.getter
      def cluster(self) -> Optional[pulumi.Input[str]]:
          """
          URI for cluster used to run Dataproc execution. Format: `projects/{PROJECT_ID}/regions/{REGION}/clusters/{CLUSTER_NAME}`
          """
          return pulumi.get(self, "cluster")
  
      @cluster.setter
      def cluster(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "cluster", value)
  
  
  @pulumi.input_type
  class EncryptionConfigArgs:
      def __init__(__self__, *,
                   kms_key: Optional[pulumi.Input[str]] = None):
          """
          Represents a custom encryption key configuration that can be applied to a resource. This will encrypt all disks in Virtual Machine.
          :param pulumi.Input[str] kms_key: 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}`
          """
          if kms_key is not None:
              pulumi.set(__self__, "kms_key", kms_key)
  
      @property
      @pulumi.getter(name="kmsKey")
      def kms_key(self) -> Optional[pulumi.Input[str]]:
          """
          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}`
          """
          return pulumi.get(self, "kms_key")
  
      @kms_key.setter
      def kms_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "kms_key", value)
  
  
  @pulumi.input_type
  class ExecutionTemplateArgs:
      def __init__(__self__, *,
                   accelerator_config: Optional[pulumi.Input['SchedulerAcceleratorConfigArgs']] = None,
                   container_image_uri: Optional[pulumi.Input[str]] = None,
                   dataproc_parameters: Optional[pulumi.Input['DataprocParametersArgs']] = None,
                   input_notebook_file: Optional[pulumi.Input[str]] = None,
                   job_type: Optional[pulumi.Input['ExecutionTemplateJobType']] = None,
                   kernel_spec: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   master_type: Optional[pulumi.Input[str]] = None,
                   output_notebook_folder: Optional[pulumi.Input[str]] = None,
                   parameters: Optional[pulumi.Input[str]] = None,
                   params_yaml_file: Optional[pulumi.Input[str]] = None,
                   service_account: Optional[pulumi.Input[str]] = None,
                   vertex_ai_parameters: Optional[pulumi.Input['VertexAIParametersArgs']] = None):
          """
          The description a notebook execution workload.
          :param pulumi.Input['SchedulerAcceleratorConfigArgs'] accelerator_config: Configuration (count and accelerator type) for hardware running notebook execution.
          :param pulumi.Input[str] container_image_uri: 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
          :param pulumi.Input['DataprocParametersArgs'] dataproc_parameters: Parameters used in Dataproc JobType executions.
          :param pulumi.Input[str] input_notebook_file: 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`
          :param pulumi.Input['ExecutionTemplateJobType'] job_type: The type of Job to be used on this execution.
          :param pulumi.Input[str] kernel_spec: 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.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: 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.
          :param pulumi.Input[str] master_type: 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).
          :param pulumi.Input[str] output_notebook_folder: 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`
          :param pulumi.Input[str] parameters: Parameters used within the 'input_notebook_file' notebook.
          :param pulumi.Input[str] params_yaml_file: 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`
          :param pulumi.Input[str] service_account: 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.
          :param pulumi.Input['VertexAIParametersArgs'] vertex_ai_parameters: Parameters used in Vertex AI JobType executions.
          """
          if accelerator_config is not None:
              pulumi.set(__self__, "accelerator_config", accelerator_config)
          if container_image_uri is not None:
              pulumi.set(__self__, "container_image_uri", container_image_uri)
          if dataproc_parameters is not None:
              pulumi.set(__self__, "dataproc_parameters", dataproc_parameters)
          if input_notebook_file is not None:
              pulumi.set(__self__, "input_notebook_file", input_notebook_file)
          if job_type is not None:
              pulumi.set(__self__, "job_type", job_type)
          if kernel_spec is not None:
              pulumi.set(__self__, "kernel_spec", kernel_spec)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if master_type is not None:
              pulumi.set(__self__, "master_type", master_type)
          if output_notebook_folder is not None:
              pulumi.set(__self__, "output_notebook_folder", output_notebook_folder)
          if parameters is not None:
              pulumi.set(__self__, "parameters", parameters)
          if params_yaml_file is not None:
              pulumi.set(__self__, "params_yaml_file", params_yaml_file)
          if service_account is not None:
              pulumi.set(__self__, "service_account", service_account)
          if vertex_ai_parameters is not None:
              pulumi.set(__self__, "vertex_ai_parameters", vertex_ai_parameters)
  
      @property
      @pulumi.getter(name="acceleratorConfig")
      def accelerator_config(self) -> Optional[pulumi.Input['SchedulerAcceleratorConfigArgs']]:
          """
          Configuration (count and accelerator type) for hardware running notebook execution.
          """
          return pulumi.get(self, "accelerator_config")
  
      @accelerator_config.setter
      def accelerator_config(self, value: Optional[pulumi.Input['SchedulerAcceleratorConfigArgs']]):
          pulumi.set(self, "accelerator_config", value)
  
      @property
      @pulumi.getter(name="containerImageUri")
      def container_image_uri(self) -> Optional[pulumi.Input[str]]:
          """
          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
          """
          return pulumi.get(self, "container_image_uri")
  
      @container_image_uri.setter
      def container_image_uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "container_image_uri", value)
  
      @property
      @pulumi.getter(name="dataprocParameters")
      def dataproc_parameters(self) -> Optional[pulumi.Input['DataprocParametersArgs']]:
          """
          Parameters used in Dataproc JobType executions.
          """
          return pulumi.get(self, "dataproc_parameters")
  
      @dataproc_parameters.setter
      def dataproc_parameters(self, value: Optional[pulumi.Input['DataprocParametersArgs']]):
          pulumi.set(self, "dataproc_parameters", value)
  
      @property
      @pulumi.getter(name="inputNotebookFile")
      def input_notebook_file(self) -> Optional[pulumi.Input[str]]:
          """
          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`
          """
          return pulumi.get(self, "input_notebook_file")
  
      @input_notebook_file.setter
      def input_notebook_file(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "input_notebook_file", value)
  
      @property
      @pulumi.getter(name="jobType")
      def job_type(self) -> Optional[pulumi.Input['ExecutionTemplateJobType']]:
          """
          The type of Job to be used on this execution.
          """
          return pulumi.get(self, "job_type")
  
      @job_type.setter
      def job_type(self, value: Optional[pulumi.Input['ExecutionTemplateJobType']]):
          pulumi.set(self, "job_type", value)
  
      @property
      @pulumi.getter(name="kernelSpec")
      def kernel_spec(self) -> Optional[pulumi.Input[str]]:
          """
          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.
          """
          return pulumi.get(self, "kernel_spec")
  
      @kernel_spec.setter
      def kernel_spec(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "kernel_spec", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          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.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter(name="masterType")
      def master_type(self) -> Optional[pulumi.Input[str]]:
          """
          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).
          """
          return pulumi.get(self, "master_type")
  
      @master_type.setter
      def master_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "master_type", value)
  
      @property
      @pulumi.getter(name="outputNotebookFolder")
      def output_notebook_folder(self) -> Optional[pulumi.Input[str]]:
          """
          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`
          """
          return pulumi.get(self, "output_notebook_folder")
  
      @output_notebook_folder.setter
      def output_notebook_folder(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "output_notebook_folder", value)
  
      @property
      @pulumi.getter
      def parameters(self) -> Optional[pulumi.Input[str]]:
          """
          Parameters used within the 'input_notebook_file' notebook.
          """
          return pulumi.get(self, "parameters")
  
      @parameters.setter
      def parameters(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "parameters", value)
  
      @property
      @pulumi.getter(name="paramsYamlFile")
      def params_yaml_file(self) -> Optional[pulumi.Input[str]]:
          """
          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`
          """
          return pulumi.get(self, "params_yaml_file")
  
      @params_yaml_file.setter
      def params_yaml_file(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "params_yaml_file", value)
  
      @property
      @pulumi.getter(name="serviceAccount")
      def service_account(self) -> Optional[pulumi.Input[str]]:
          """
          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.
          """
          return pulumi.get(self, "service_account")
  
      @service_account.setter
      def service_account(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_account", value)
  
      @property
      @pulumi.getter(name="vertexAiParameters")
      def vertex_ai_parameters(self) -> Optional[pulumi.Input['VertexAIParametersArgs']]:
          """
          Parameters used in Vertex AI JobType executions.
          """
          return pulumi.get(self, "vertex_ai_parameters")
  
      @vertex_ai_parameters.setter
      def vertex_ai_parameters(self, value: Optional[pulumi.Input['VertexAIParametersArgs']]):
          pulumi.set(self, "vertex_ai_parameters", value)
  
  
  @pulumi.input_type
  class ExprArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   expression: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   title: Optional[pulumi.Input[str]] = None):
          """
          Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
          :param pulumi.Input[str] description: Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
          :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
          :param pulumi.Input[str] location: Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
          :param pulumi.Input[str] title: Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if expression is not None:
              pulumi.set(__self__, "expression", expression)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if title is not None:
              pulumi.set(__self__, "title", title)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter
      def expression(self) -> Optional[pulumi.Input[str]]:
          """
          Textual representation of an expression in Common Expression Language syntax.
          """
          return pulumi.get(self, "expression")
  
      @expression.setter
      def expression(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "expression", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter
      def title(self) -> Optional[pulumi.Input[str]]:
          """
          Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
          """
          return pulumi.get(self, "title")
  
      @title.setter
      def title(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "title", value)
  
  
  @pulumi.input_type
  class LocalDiskInitializeParamsArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   disk_name: Optional[pulumi.Input[str]] = None,
                   disk_size_gb: Optional[pulumi.Input[str]] = None,
                   disk_type: Optional[pulumi.Input['LocalDiskInitializeParamsDiskType']] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          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.
          :param pulumi.Input[str] description: Optional. Provide this property when creating the disk.
          :param pulumi.Input[str] disk_name: 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.
          :param pulumi.Input[str] disk_size_gb: 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.
          :param pulumi.Input['LocalDiskInitializeParamsDiskType'] disk_type: Input only. The type of the boot disk attached to this instance, defaults to standard persistent disk (`PD_STANDARD`).
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: 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.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if disk_name is not None:
              pulumi.set(__self__, "disk_name", disk_name)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if disk_type is not None:
              pulumi.set(__self__, "disk_type", disk_type)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Optional. Provide this property when creating the disk.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="diskName")
      def disk_name(self) -> Optional[pulumi.Input[str]]:
          """
          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.
          """
          return pulumi.get(self, "disk_name")
  
      @disk_name.setter
      def disk_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_name", value)
  
      @property
      @pulumi.getter(name="diskSizeGb")
      def disk_size_gb(self) -> Optional[pulumi.Input[str]]:
          """
          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.
          """
          return pulumi.get(self, "disk_size_gb")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter(name="diskType")
      def disk_type(self) -> Optional[pulumi.Input['LocalDiskInitializeParamsDiskType']]:
          """
          Input only. The type of the boot disk attached to this instance, defaults to standard persistent disk (`PD_STANDARD`).
          """
          return pulumi.get(self, "disk_type")
  
      @disk_type.setter
      def disk_type(self, value: Optional[pulumi.Input['LocalDiskInitializeParamsDiskType']]):
          pulumi.set(self, "disk_type", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          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.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
  
  @pulumi.input_type
  class LocalDiskArgs:
      def __init__(__self__, *,
                   initialize_params: Optional[pulumi.Input['LocalDiskInitializeParamsArgs']] = None,
                   interface: Optional[pulumi.Input[str]] = None,
                   mode: Optional[pulumi.Input[str]] = None,
                   source: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          A Local attached disk resource.
          :param pulumi.Input['LocalDiskInitializeParamsArgs'] initialize_params: 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 instance. This property is mutually exclusive with the source property; you can only define one or the other, but not both.
          :param pulumi.Input[str] interface: 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
          :param pulumi.Input[str] mode: 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
          :param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource.
          :param pulumi.Input[str] type: Specifies the type of the disk, either SCRATCH or PERSISTENT. If not specified, the default is PERSISTENT. Valid values: * PERSISTENT * SCRATCH
          """
          if initialize_params is not None:
              pulumi.set(__self__, "initialize_params", initialize_params)
          if interface is not None:
              pulumi.set(__self__, "interface", interface)
          if mode is not None:
              pulumi.set(__self__, "mode", mode)
          if source is not None:
              pulumi.set(__self__, "source", source)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="initializeParams")
      def initialize_params(self) -> Optional[pulumi.Input['LocalDiskInitializeParamsArgs']]:
          """
          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 instance. This property is mutually exclusive with the source property; you can only define one or the other, but not both.
          """
          return pulumi.get(self, "initialize_params")
  
      @initialize_params.setter
      def initialize_params(self, value: Optional[pulumi.Input['LocalDiskInitializeParamsArgs']]):
          pulumi.set(self, "initialize_params", value)
  
      @property
      @pulumi.getter
      def interface(self) -> Optional[pulumi.Input[str]]:
          """
          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
          """
          return pulumi.get(self, "interface")
  
      @interface.setter
      def interface(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "interface", value)
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[pulumi.Input[str]]:
          """
          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
          """
          return pulumi.get(self, "mode")
  
      @mode.setter
      def mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mode", value)
  
      @property
      @pulumi.getter
      def source(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies a valid partial or full URL to an existing Persistent Disk resource.
          """
          return pulumi.get(self, "source")
  
      @source.setter
      def source(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "source", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the type of the disk, either SCRATCH or PERSISTENT. If not specified, the default is PERSISTENT. Valid values: * PERSISTENT * SCRATCH
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ReservationAffinityArgs:
      def __init__(__self__, *,
                   consume_reservation_type: Optional[pulumi.Input['ReservationAffinityConsumeReservationType']] = None,
                   key: Optional[pulumi.Input[str]] = None,
                   values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Reservation Affinity for consuming Zonal reservation.
          :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Optional. Type of reservation to consume
          :param pulumi.Input[str] key: Optional. Corresponds to the label key of reservation resource.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Optional. Corresponds to the label values of reservation resource.
          """
          if consume_reservation_type is not None:
              pulumi.set(__self__, "consume_reservation_type", consume_reservation_type)
          if key is not None:
              pulumi.set(__self__, "key", key)
          if values is not None:
              pulumi.set(__self__, "values", values)
  
      @property
      @pulumi.getter(name="consumeReservationType")
      def consume_reservation_type(self) -> Optional[pulumi.Input['ReservationAffinityConsumeReservationType']]:
          """
          Optional. Type of reservation to consume
          """
          return pulumi.get(self, "consume_reservation_type")
  
      @consume_reservation_type.setter
      def consume_reservation_type(self, value: Optional[pulumi.Input['ReservationAffinityConsumeReservationType']]):
          pulumi.set(self, "consume_reservation_type", value)
  
      @property
      @pulumi.getter
      def key(self) -> Optional[pulumi.Input[str]]:
          """
          Optional. Corresponds to the label key of reservation resource.
          """
          return pulumi.get(self, "key")
  
      @key.setter
      def key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "key", value)
  
      @property
      @pulumi.getter
      def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Optional. Corresponds to the label values of reservation resource.
          """
          return pulumi.get(self, "values")
  
      @values.setter
      def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "values", value)
  
  
  @pulumi.input_type
  class RuntimeAcceleratorConfigArgs:
      def __init__(__self__, *,
                   core_count: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input['RuntimeAcceleratorConfigType']] = None):
          """
          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`
          :param pulumi.Input[str] core_count: Count of cores of this accelerator.
          :param pulumi.Input['RuntimeAcceleratorConfigType'] type: Accelerator model.
          """
          if core_count is not None:
              pulumi.set(__self__, "core_count", core_count)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="coreCount")
      def core_count(self) -> Optional[pulumi.Input[str]]:
          """
          Count of cores of this accelerator.
          """
          return pulumi.get(self, "core_count")
  
      @core_count.setter
      def core_count(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "core_count", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input['RuntimeAcceleratorConfigType']]:
          """
          Accelerator model.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input['RuntimeAcceleratorConfigType']]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class RuntimeAccessConfigArgs:
      def __init__(__self__, *,
                   access_type: Optional[pulumi.Input['RuntimeAccessConfigAccessType']] = None,
                   runtime_owner: Optional[pulumi.Input[str]] = None):
          """
          Specifies the login configuration for Runtime
          :param pulumi.Input['RuntimeAccessConfigAccessType'] access_type: The type of access mode this instance.
          :param pulumi.Input[str] runtime_owner: The owner of this runtime after creation. Format: `alias@example.com` Currently supports one owner only.
          """
          if access_type is not None:
              pulumi.set(__self__, "access_type", access_type)
          if runtime_owner is not None:
              pulumi.set(__self__, "runtime_owner", runtime_owner)
  
      @property
      @pulumi.getter(name="accessType")
      def access_type(self) -> Optional[pulumi.Input['RuntimeAccessConfigAccessType']]:
          """
          The type of access mode this instance.
          """
          return pulumi.get(self, "access_type")
  
      @access_type.setter
      def access_type(self, value: Optional[pulumi.Input['RuntimeAccessConfigAccessType']]):
          pulumi.set(self, "access_type", value)
  
      @property
      @pulumi.getter(name="runtimeOwner")
      def runtime_owner(self) -> Optional[pulumi.Input[str]]:
          """
          The owner of this runtime after creation. Format: `alias@example.com` Currently supports one owner only.
          """
          return pulumi.get(self, "runtime_owner")
  
      @runtime_owner.setter
      def runtime_owner(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "runtime_owner", value)
  
  
  @pulumi.input_type
  class RuntimeShieldedInstanceConfigArgs:
      def __init__(__self__, *,
                   enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                   enable_secure_boot: Optional[pulumi.Input[bool]] = None,
                   enable_vtpm: Optional[pulumi.Input[bool]] = None):
          """
          A set of Shielded Instance options. Check [Images using supported Shielded VM features](https://cloud.google.com/compute/docs/instances/modifying-shielded-vm). Not all combinations are valid.
          :param pulumi.Input[bool] enable_integrity_monitoring: 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.
          :param pulumi.Input[bool] enable_secure_boot: 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.
          :param pulumi.Input[bool] enable_vtpm: Defines whether the instance has the vTPM enabled. Enabled by default.
          """
          if enable_integrity_monitoring is not None:
              pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
          if enable_secure_boot is not None:
              pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
          if enable_vtpm is not None:
              pulumi.set(__self__, "enable_vtpm", enable_vtpm)
  
      @property
      @pulumi.getter(name="enableIntegrityMonitoring")
      def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
          """
          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.
          """
          return pulumi.get(self, "enable_integrity_monitoring")
  
      @enable_integrity_monitoring.setter
      def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_integrity_monitoring", value)
  
      @property
      @pulumi.getter(name="enableSecureBoot")
      def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
          """
          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.
          """
          return pulumi.get(self, "enable_secure_boot")
  
      @enable_secure_boot.setter
      def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_secure_boot", value)
  
      @property
      @pulumi.getter(name="enableVtpm")
      def enable_vtpm(self) -> Optional[pulumi.Input[bool]]:
          """
          Defines whether the instance has the vTPM enabled. Enabled by default.
          """
          return pulumi.get(self, "enable_vtpm")
  
      @enable_vtpm.setter
      def enable_vtpm(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_vtpm", value)
  
  
  @pulumi.input_type
  class RuntimeSoftwareConfigArgs:
      def __init__(__self__, *,
                   custom_gpu_driver_path: Optional[pulumi.Input[str]] = None,
                   enable_health_monitoring: Optional[pulumi.Input[bool]] = None,
                   idle_shutdown: Optional[pulumi.Input[bool]] = None,
                   idle_shutdown_timeout: Optional[pulumi.Input[int]] = None,
                   install_gpu_driver: Optional[pulumi.Input[bool]] = None,
                   notebook_upgrade_schedule: Optional[pulumi.Input[str]] = None,
                   post_startup_script: Optional[pulumi.Input[str]] = None):
          """
          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` * `report-system-health: true`
          :param pulumi.Input[str] custom_gpu_driver_path: Specify a custom Cloud Storage path where the GPU driver is stored. If not specified, we'll automatically choose from official GPU drivers.
          :param pulumi.Input[bool] enable_health_monitoring: Verifies core internal services are running. Default: True
          :param pulumi.Input[bool] idle_shutdown: Runtime will automatically shutdown after idle_shutdown_time. Default: True
          :param pulumi.Input[int] idle_shutdown_timeout: Time in minutes to wait before shutting down runtime. Default: 180 minutes
          :param pulumi.Input[bool] install_gpu_driver: Install Nvidia Driver automatically.
          :param pulumi.Input[str] notebook_upgrade_schedule: Cron expression in UTC timezone, used to schedule instance auto upgrade. Please follow the [cron format](https://en.wikipedia.org/wiki/Cron).
          :param pulumi.Input[str] post_startup_script: 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`).
          """
          if custom_gpu_driver_path is not None:
              pulumi.set(__self__, "custom_gpu_driver_path", custom_gpu_driver_path)
          if enable_health_monitoring is not None:
              pulumi.set(__self__, "enable_health_monitoring", enable_health_monitoring)
          if idle_shutdown is not None:
              pulumi.set(__self__, "idle_shutdown", idle_shutdown)
          if idle_shutdown_timeout is not None:
              pulumi.set(__self__, "idle_shutdown_timeout", idle_shutdown_timeout)
          if install_gpu_driver is not None:
              pulumi.set(__self__, "install_gpu_driver", install_gpu_driver)
          if notebook_upgrade_schedule is not None:
              pulumi.set(__self__, "notebook_upgrade_schedule", notebook_upgrade_schedule)
          if post_startup_script is not None:
              pulumi.set(__self__, "post_startup_script", post_startup_script)
  
      @property
      @pulumi.getter(name="customGpuDriverPath")
      def custom_gpu_driver_path(self) -> Optional[pulumi.Input[str]]:
          """
          Specify a custom Cloud Storage path where the GPU driver is stored. If not specified, we'll automatically choose from official GPU drivers.
          """
          return pulumi.get(self, "custom_gpu_driver_path")
  
      @custom_gpu_driver_path.setter
      def custom_gpu_driver_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "custom_gpu_driver_path", value)
  
      @property
      @pulumi.getter(name="enableHealthMonitoring")
      def enable_health_monitoring(self) -> Optional[pulumi.Input[bool]]:
          """
          Verifies core internal services are running. Default: True
          """
          return pulumi.get(self, "enable_health_monitoring")
  
      @enable_health_monitoring.setter
      def enable_health_monitoring(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_health_monitoring", value)
  
      @property
      @pulumi.getter(name="idleShutdown")
      def idle_shutdown(self) -> Optional[pulumi.Input[bool]]:
          """
          Runtime will automatically shutdown after idle_shutdown_time. Default: True
          """
          return pulumi.get(self, "idle_shutdown")
  
      @idle_shutdown.setter
      def idle_shutdown(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "idle_shutdown", value)
  
      @property
      @pulumi.getter(name="idleShutdownTimeout")
      def idle_shutdown_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Time in minutes to wait before shutting down runtime. Default: 180 minutes
          """
          return pulumi.get(self, "idle_shutdown_timeout")
  
      @idle_shutdown_timeout.setter
      def idle_shutdown_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_shutdown_timeout", value)
  
      @property
      @pulumi.getter(name="installGpuDriver")
      def install_gpu_driver(self) -> Optional[pulumi.Input[bool]]:
          """
          Install Nvidia Driver automatically.
          """
          return pulumi.get(self, "install_gpu_driver")
  
      @install_gpu_driver.setter
      def install_gpu_driver(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "install_gpu_driver", value)
  
      @property
      @pulumi.getter(name="notebookUpgradeSchedule")
      def notebook_upgrade_schedule(self) -> Optional[pulumi.Input[str]]:
          """
          Cron expression in UTC timezone, used to schedule instance auto upgrade. Please follow the [cron format](https://en.wikipedia.org/wiki/Cron).
          """
          return pulumi.get(self, "notebook_upgrade_schedule")
  
      @notebook_upgrade_schedule.setter
      def notebook_upgrade_schedule(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "notebook_upgrade_schedule", value)
  
      @property
      @pulumi.getter(name="postStartupScript")
      def post_startup_script(self) -> Optional[pulumi.Input[str]]:
          """
          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`).
          """
          return pulumi.get(self, "post_startup_script")
  
      @post_startup_script.setter
      def post_startup_script(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "post_startup_script", value)
  
  
  @pulumi.input_type
  class SchedulerAcceleratorConfigArgs:
      def __init__(__self__, *,
                   core_count: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input['SchedulerAcceleratorConfigType']] = None):
          """
          Definition of a hardware accelerator. Note that not all combinations of `type` and `core_count` are valid. Check [GPUs on Compute Engine](https://cloud.google.com/compute/docs/gpus) to find a valid combination. TPUs are not supported.
          :param pulumi.Input[str] core_count: Count of cores of this accelerator.
          :param pulumi.Input['SchedulerAcceleratorConfigType'] type: Type of this accelerator.
          """
          if core_count is not None:
              pulumi.set(__self__, "core_count", core_count)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="coreCount")
      def core_count(self) -> Optional[pulumi.Input[str]]:
          """
          Count of cores of this accelerator.
          """
          return pulumi.get(self, "core_count")
  
      @core_count.setter
      def core_count(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "core_count", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input['SchedulerAcceleratorConfigType']]:
          """
          Type of this accelerator.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input['SchedulerAcceleratorConfigType']]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ShieldedInstanceConfigArgs:
      def __init__(__self__, *,
                   enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                   enable_secure_boot: Optional[pulumi.Input[bool]] = None,
                   enable_vtpm: Optional[pulumi.Input[bool]] = None):
          """
          A set of Shielded Instance options. Check [Images using supported Shielded VM features] Not all combinations are valid.
          :param pulumi.Input[bool] enable_integrity_monitoring: 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.
          :param pulumi.Input[bool] enable_secure_boot: 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.
          :param pulumi.Input[bool] enable_vtpm: Defines whether the instance has the vTPM enabled. Enabled by default.
          """
          if enable_integrity_monitoring is not None:
              pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
          if enable_secure_boot is not None:
              pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
          if enable_vtpm is not None:
              pulumi.set(__self__, "enable_vtpm", enable_vtpm)
  
      @property
      @pulumi.getter(name="enableIntegrityMonitoring")
      def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
          """
          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.
          """
          return pulumi.get(self, "enable_integrity_monitoring")
  
      @enable_integrity_monitoring.setter
      def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_integrity_monitoring", value)
  
      @property
      @pulumi.getter(name="enableSecureBoot")
      def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
          """
          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.
          """
          return pulumi.get(self, "enable_secure_boot")
  
      @enable_secure_boot.setter
      def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_secure_boot", value)
  
      @property
      @pulumi.getter(name="enableVtpm")
      def enable_vtpm(self) -> Optional[pulumi.Input[bool]]:
          """
          Defines whether the instance has the vTPM enabled. Enabled by default.
          """
          return pulumi.get(self, "enable_vtpm")
  
      @enable_vtpm.setter
      def enable_vtpm(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_vtpm", value)
  
  
  @pulumi.input_type
  class UpgradeHistoryEntryArgs:
      def __init__(__self__, *,
                   action: Optional[pulumi.Input['UpgradeHistoryEntryAction']] = None,
                   container_image: Optional[pulumi.Input[str]] = None,
                   create_time: Optional[pulumi.Input[str]] = None,
                   framework: Optional[pulumi.Input[str]] = None,
                   snapshot: Optional[pulumi.Input[str]] = None,
                   state: Optional[pulumi.Input['UpgradeHistoryEntryState']] = None,
                   target_image: Optional[pulumi.Input[str]] = None,
                   target_version: Optional[pulumi.Input[str]] = None,
                   version: Optional[pulumi.Input[str]] = None,
                   vm_image: Optional[pulumi.Input[str]] = None):
          """
          The entry of VM image upgrade history.
          :param pulumi.Input['UpgradeHistoryEntryAction'] action: Action. Rolloback or Upgrade.
          :param pulumi.Input[str] container_image: The container image before this instance upgrade.
          :param pulumi.Input[str] create_time: The time that this instance upgrade history entry is created.
          :param pulumi.Input[str] framework: The framework of this notebook instance.
          :param pulumi.Input[str] snapshot: The snapshot of the boot disk of this notebook instance before upgrade.
          :param pulumi.Input['UpgradeHistoryEntryState'] state: The state of this instance upgrade history entry.
          :param pulumi.Input[str] target_image: Target VM Image. Format: ainotebooks-vm/project/image-name/name.
          :param pulumi.Input[str] target_version: Target VM Version, like m63.
          :param pulumi.Input[str] version: The version of the notebook instance before this upgrade.
          :param pulumi.Input[str] vm_image: The VM image before this instance upgrade.
          """
          if action is not None:
              pulumi.set(__self__, "action", action)
          if container_image is not None:
              pulumi.set(__self__, "container_image", container_image)
          if create_time is not None:
              pulumi.set(__self__, "create_time", create_time)
          if framework is not None:
              pulumi.set(__self__, "framework", framework)
          if snapshot is not None:
              pulumi.set(__self__, "snapshot", snapshot)
          if state is not None:
              pulumi.set(__self__, "state", state)
          if target_image is not None:
              pulumi.set(__self__, "target_image", target_image)
          if target_version is not None:
              pulumi.set(__self__, "target_version", target_version)
          if version is not None:
              pulumi.set(__self__, "version", version)
          if vm_image is not None:
              pulumi.set(__self__, "vm_image", vm_image)
  
      @property
      @pulumi.getter
      def action(self) -> Optional[pulumi.Input['UpgradeHistoryEntryAction']]:
          """
          Action. Rolloback or Upgrade.
          """
          return pulumi.get(self, "action")
  
      @action.setter
      def action(self, value: Optional[pulumi.Input['UpgradeHistoryEntryAction']]):
          pulumi.set(self, "action", value)
  
      @property
      @pulumi.getter(name="containerImage")
      def container_image(self) -> Optional[pulumi.Input[str]]:
          """
          The container image before this instance upgrade.
          """
          return pulumi.get(self, "container_image")
  
      @container_image.setter
      def container_image(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "container_image", value)
  
      @property
      @pulumi.getter(name="createTime")
      def create_time(self) -> Optional[pulumi.Input[str]]:
          """
          The time that this instance upgrade history entry is created.
          """
          return pulumi.get(self, "create_time")
  
      @create_time.setter
      def create_time(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "create_time", value)
  
      @property
      @pulumi.getter
      def framework(self) -> Optional[pulumi.Input[str]]:
          """
          The framework of this notebook instance.
          """
          return pulumi.get(self, "framework")
  
      @framework.setter
      def framework(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "framework", value)
  
      @property
      @pulumi.getter
      def snapshot(self) -> Optional[pulumi.Input[str]]:
          """
          The snapshot of the boot disk of this notebook instance before upgrade.
          """
          return pulumi.get(self, "snapshot")
  
      @snapshot.setter
      def snapshot(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "snapshot", value)
  
      @property
      @pulumi.getter
      def state(self) -> Optional[pulumi.Input['UpgradeHistoryEntryState']]:
          """
          The state of this instance upgrade history entry.
          """
          return pulumi.get(self, "state")
  
      @state.setter
      def state(self, value: Optional[pulumi.Input['UpgradeHistoryEntryState']]):
          pulumi.set(self, "state", value)
  
      @property
      @pulumi.getter(name="targetImage")
      def target_image(self) -> Optional[pulumi.Input[str]]:
          """
          Target VM Image. Format: ainotebooks-vm/project/image-name/name.
          """
          return pulumi.get(self, "target_image")
  
      @target_image.setter
      def target_image(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_image", value)
  
      @property
      @pulumi.getter(name="targetVersion")
      def target_version(self) -> Optional[pulumi.Input[str]]:
          """
          Target VM Version, like m63.
          """
          return pulumi.get(self, "target_version")
  
      @target_version.setter
      def target_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_version", value)
  
      @property
      @pulumi.getter
      def version(self) -> Optional[pulumi.Input[str]]:
          """
          The version of the notebook instance before this upgrade.
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "version", value)
  
      @property
      @pulumi.getter(name="vmImage")
      def vm_image(self) -> Optional[pulumi.Input[str]]:
          """
          The VM image before this instance upgrade.
          """
          return pulumi.get(self, "vm_image")
  
      @vm_image.setter
      def vm_image(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "vm_image", value)
  
  
  @pulumi.input_type
  class VertexAIParametersArgs:
      def __init__(__self__, *,
                   env: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   network: Optional[pulumi.Input[str]] = None):
          """
          Parameters used in Vertex AI JobType executions.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] env: Environment variables. At most 100 environment variables can be specified and unique. Example: GCP_BUCKET=gs://my-bucket/samples/
          :param pulumi.Input[str] network: The full name of the Compute Engine [network](/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.
          """
          if env is not None:
              pulumi.set(__self__, "env", env)
          if network is not None:
              pulumi.set(__self__, "network", network)
  
      @property
      @pulumi.getter
      def env(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Environment variables. At most 100 environment variables can be specified and unique. Example: GCP_BUCKET=gs://my-bucket/samples/
          """
          return pulumi.get(self, "env")
  
      @env.setter
      def env(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "env", value)
  
      @property
      @pulumi.getter
      def network(self) -> Optional[pulumi.Input[str]]:
          """
          The full name of the Compute Engine [network](/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.
          """
          return pulumi.get(self, "network")
  
      @network.setter
      def network(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "network", value)
  
  
  @pulumi.input_type
  class VirtualMachineConfigArgs:
      def __init__(__self__, *,
                   data_disk: pulumi.Input['LocalDiskArgs'],
                   machine_type: pulumi.Input[str],
                   accelerator_config: Optional[pulumi.Input['RuntimeAcceleratorConfigArgs']] = None,
                   container_images: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerImageArgs']]]] = None,
                   encryption_config: Optional[pulumi.Input['EncryptionConfigArgs']] = None,
                   internal_ip_only: Optional[pulumi.Input[bool]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   network: Optional[pulumi.Input[str]] = None,
                   nic_type: Optional[pulumi.Input['VirtualMachineConfigNicType']] = None,
                   shielded_instance_config: Optional[pulumi.Input['RuntimeShieldedInstanceConfigArgs']] = None,
                   subnet: Optional[pulumi.Input[str]] = None,
                   tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          The config settings for virtual machine.
          :param pulumi.Input['LocalDiskArgs'] data_disk: Data disk option configuration settings.
          :param pulumi.Input[str] machine_type: The Compute Engine machine type used for runtimes. Short name is valid. Examples: * `n1-standard-2` * `e2-standard-8`
          :param pulumi.Input['RuntimeAcceleratorConfigArgs'] accelerator_config: Optional. The Compute Engine accelerator configuration for this runtime.
          :param pulumi.Input[Sequence[pulumi.Input['ContainerImageArgs']]] container_images: Optional. Use a list of container images to start the notebook instance.
          :param pulumi.Input['EncryptionConfigArgs'] encryption_config: Optional. Encryption settings for virtual machine data disk.
          :param pulumi.Input[bool] internal_ip_only: 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.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: 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.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: 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)).
          :param pulumi.Input[str] network: 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]/regions/global/default` * `projects/[project_id]/regions/global/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.
          :param pulumi.Input['VirtualMachineConfigNicType'] nic_type: Optional. The type of vNIC to be used on this interface. This may be gVNIC or VirtioNet.
          :param pulumi.Input['RuntimeShieldedInstanceConfigArgs'] shielded_instance_config: Optional. Shielded VM Instance configuration settings.
          :param pulumi.Input[str] subnet: 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`
          :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Optional. The Compute Engine tags to add to runtime (see [Tagging instances](https://cloud.google.com/compute/docs/label-or-tag-resources#tags)).
          """
          pulumi.set(__self__, "data_disk", data_disk)
          pulumi.set(__self__, "machine_type", machine_type)
          if accelerator_config is not None:
              pulumi.set(__self__, "accelerator_config", accelerator_config)
          if container_images is not None:
              pulumi.set(__self__, "container_images", container_images)
          if encryption_config is not None:
              pulumi.set(__self__, "encryption_config", encryption_config)
          if internal_ip_only is not None:
              pulumi.set(__self__, "internal_ip_only", internal_ip_only)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if metadata is not None:
              pulumi.set(__self__, "metadata", metadata)
          if network is not None:
              pulumi.set(__self__, "network", network)
          if nic_type is not None:
              pulumi.set(__self__, "nic_type", nic_type)
          if shielded_instance_config is not None:
              pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter(name="dataDisk")
      def data_disk(self) -> pulumi.Input['LocalDiskArgs']:
          """
          Data disk option configuration settings.
          """
          return pulumi.get(self, "data_disk")
  
      @data_disk.setter
      def data_disk(self, value: pulumi.Input['LocalDiskArgs']):
          pulumi.set(self, "data_disk", value)
  
      @property
      @pulumi.getter(name="machineType")
      def machine_type(self) -> pulumi.Input[str]:
          """
          The Compute Engine machine type used for runtimes. Short name is valid. Examples: * `n1-standard-2` * `e2-standard-8`
          """
          return pulumi.get(self, "machine_type")
  
      @machine_type.setter
      def machine_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "machine_type", value)
  
      @property
      @pulumi.getter(name="acceleratorConfig")
      def accelerator_config(self) -> Optional[pulumi.Input['RuntimeAcceleratorConfigArgs']]:
          """
          Optional. The Compute Engine accelerator configuration for this runtime.
          """
          return pulumi.get(self, "accelerator_config")
  
      @accelerator_config.setter
      def accelerator_config(self, value: Optional[pulumi.Input['RuntimeAcceleratorConfigArgs']]):
          pulumi.set(self, "accelerator_config", value)
  
      @property
      @pulumi.getter(name="containerImages")
      def container_images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerImageArgs']]]]:
          """
          Optional. Use a list of container images to start the notebook instance.
          """
          return pulumi.get(self, "container_images")
  
      @container_images.setter
      def container_images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerImageArgs']]]]):
          pulumi.set(self, "container_images", value)
  
      @property
      @pulumi.getter(name="encryptionConfig")
      def encryption_config(self) -> Optional[pulumi.Input['EncryptionConfigArgs']]:
          """
          Optional. Encryption settings for virtual machine data disk.
          """
          return pulumi.get(self, "encryption_config")
  
      @encryption_config.setter
      def encryption_config(self, value: Optional[pulumi.Input['EncryptionConfigArgs']]):
          pulumi.set(self, "encryption_config", value)
  
      @property
      @pulumi.getter(name="internalIpOnly")
      def internal_ip_only(self) -> Optional[pulumi.Input[bool]]:
          """
          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.
          """
          return pulumi.get(self, "internal_ip_only")
  
      @internal_ip_only.setter
      def internal_ip_only(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "internal_ip_only", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          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.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          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)).
          """
          return pulumi.get(self, "metadata")
  
      @metadata.setter
      def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "metadata", value)
  
      @property
      @pulumi.getter
      def network(self) -> Optional[pulumi.Input[str]]:
          """
          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]/regions/global/default` * `projects/[project_id]/regions/global/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.
          """
          return pulumi.get(self, "network")
  
      @network.setter
      def network(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "network", value)
  
      @property
      @pulumi.getter(name="nicType")
      def nic_type(self) -> Optional[pulumi.Input['VirtualMachineConfigNicType']]:
          """
          Optional. The type of vNIC to be used on this interface. This may be gVNIC or VirtioNet.
          """
          return pulumi.get(self, "nic_type")
  
      @nic_type.setter
      def nic_type(self, value: Optional[pulumi.Input['VirtualMachineConfigNicType']]):
          pulumi.set(self, "nic_type", value)
  
      @property
      @pulumi.getter(name="shieldedInstanceConfig")
      def shielded_instance_config(self) -> Optional[pulumi.Input['RuntimeShieldedInstanceConfigArgs']]:
          """
          Optional. Shielded VM Instance configuration settings.
          """
          return pulumi.get(self, "shielded_instance_config")
  
      @shielded_instance_config.setter
      def shielded_instance_config(self, value: Optional[pulumi.Input['RuntimeShieldedInstanceConfigArgs']]):
          pulumi.set(self, "shielded_instance_config", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input[str]]:
          """
          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`
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Optional. The Compute Engine tags to add to runtime (see [Tagging instances](https://cloud.google.com/compute/docs/label-or-tag-resources#tags)).
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class VirtualMachineArgs:
      def __init__(__self__, *,
                   virtual_machine_config: Optional[pulumi.Input['VirtualMachineConfigArgs']] = None):
          """
          Runtime using Virtual Machine for computing.
          :param pulumi.Input['VirtualMachineConfigArgs'] virtual_machine_config: Virtual Machine configuration settings.
          """
          if virtual_machine_config is not None:
              pulumi.set(__self__, "virtual_machine_config", virtual_machine_config)
  
      @property
      @pulumi.getter(name="virtualMachineConfig")
      def virtual_machine_config(self) -> Optional[pulumi.Input['VirtualMachineConfigArgs']]:
          """
          Virtual Machine configuration settings.
          """
          return pulumi.get(self, "virtual_machine_config")
  
      @virtual_machine_config.setter
      def virtual_machine_config(self, value: Optional[pulumi.Input['VirtualMachineConfigArgs']]):
          pulumi.set(self, "virtual_machine_config", value)
  
  
  @pulumi.input_type
  class VmImageArgs:
      def __init__(__self__, *,
                   project: pulumi.Input[str],
                   image_family: Optional[pulumi.Input[str]] = None,
                   image_name: Optional[pulumi.Input[str]] = None):
          """
          Definition of a custom Compute Engine virtual machine image for starting a notebook instance with the environment installed directly on the VM.
          :param pulumi.Input[str] project: The name of the Google Cloud project that this VM image belongs to. Format: `projects/{project_id}`
          :param pulumi.Input[str] image_family: Use this VM image family to find the image; the newest image in this family will be used.
          :param pulumi.Input[str] image_name: Use VM image name to find the image.
          """
          pulumi.set(__self__, "project", project)
          if image_family is not None:
              pulumi.set(__self__, "image_family", image_family)
          if image_name is not None:
              pulumi.set(__self__, "image_name", image_name)
  
      @property
      @pulumi.getter
      def project(self) -> pulumi.Input[str]:
          """
          The name of the Google Cloud project that this VM image belongs to. Format: `projects/{project_id}`
          """
          return pulumi.get(self, "project")
  
      @project.setter
      def project(self, value: pulumi.Input[str]):
          pulumi.set(self, "project", value)
  
      @property
      @pulumi.getter(name="imageFamily")
      def image_family(self) -> Optional[pulumi.Input[str]]:
          """
          Use this VM image family to find the image; the newest image in this family will be used.
          """
          return pulumi.get(self, "image_family")
  
      @image_family.setter
      def image_family(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "image_family", value)
  
      @property
      @pulumi.getter(name="imageName")
      def image_name(self) -> Optional[pulumi.Input[str]]:
          """
          Use VM image name to find the image.
          """
          return pulumi.get(self, "image_name")
  
      @image_name.setter
      def image_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "image_name", value)
  
  
  