All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.gcp.notebooks.kotlin.InstanceArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 8.10.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.notebooks.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.notebooks.InstanceArgs.builder
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceAcceleratorConfigArgs
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceAcceleratorConfigArgsBuilder
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceContainerImageArgs
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceContainerImageArgsBuilder
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceReservationAffinityArgs
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceReservationAffinityArgsBuilder
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceShieldedInstanceConfigArgs
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceShieldedInstanceConfigArgsBuilder
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceVmImageArgs
import com.pulumi.gcp.notebooks.kotlin.inputs.InstanceVmImageArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Int
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 * > **Warning:** `google_notebook_instance` is deprecated and will be removed in a future major release. Use `gcp.workbench.Instance` instead.
 * A Cloud AI Platform Notebook instance.
 * > **Note:** Due to limitations of the Notebooks Instance API, many fields
 * in this resource do not properly detect drift. These fields will also not
 * appear in state once imported.
 * To get more information about Instance, see:
 * * [API documentation](https://cloud.google.com/ai-platform/notebooks/docs/reference/rest)
 * * How-to Guides
 *     * [Official Documentation](https://cloud.google.com/ai-platform-notebooks)
 * ## Example Usage
 * ### Notebook Instance Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const instance = new gcp.notebooks.Instance("instance", {
 *     name: "notebooks-instance",
 *     location: "us-west1-a",
 *     machineType: "e2-medium",
 *     vmImage: {
 *         project: "deeplearning-platform-release",
 *         imageFamily: "tf-latest-cpu",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * instance = gcp.notebooks.Instance("instance",
 *     name="notebooks-instance",
 *     location="us-west1-a",
 *     machine_type="e2-medium",
 *     vm_image=gcp.notebooks.InstanceVmImageArgs(
 *         project="deeplearning-platform-release",
 *         image_family="tf-latest-cpu",
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var instance = new Gcp.Notebooks.Instance("instance", new()
 *     {
 *         Name = "notebooks-instance",
 *         Location = "us-west1-a",
 *         MachineType = "e2-medium",
 *         VmImage = new Gcp.Notebooks.Inputs.InstanceVmImageArgs
 *         {
 *             Project = "deeplearning-platform-release",
 *             ImageFamily = "tf-latest-cpu",
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/notebooks"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := notebooks.NewInstance(ctx, "instance", ¬ebooks.InstanceArgs{
 * 			Name:        pulumi.String("notebooks-instance"),
 * 			Location:    pulumi.String("us-west1-a"),
 * 			MachineType: pulumi.String("e2-medium"),
 * 			VmImage: ¬ebooks.InstanceVmImageArgs{
 * 				Project:     pulumi.String("deeplearning-platform-release"),
 * 				ImageFamily: pulumi.String("tf-latest-cpu"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.notebooks.Instance;
 * import com.pulumi.gcp.notebooks.InstanceArgs;
 * import com.pulumi.gcp.notebooks.inputs.InstanceVmImageArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var instance = new Instance("instance", InstanceArgs.builder()
 *             .name("notebooks-instance")
 *             .location("us-west1-a")
 *             .machineType("e2-medium")
 *             .vmImage(InstanceVmImageArgs.builder()
 *                 .project("deeplearning-platform-release")
 *                 .imageFamily("tf-latest-cpu")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   instance:
 *     type: gcp:notebooks:Instance
 *     properties:
 *       name: notebooks-instance
 *       location: us-west1-a
 *       machineType: e2-medium
 *       vmImage:
 *         project: deeplearning-platform-release
 *         imageFamily: tf-latest-cpu
 * ```
 * 
 * ### Notebook Instance Basic Stopped
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const instance = new gcp.notebooks.Instance("instance", {
 *     name: "notebooks-instance",
 *     location: "us-west1-a",
 *     machineType: "e2-medium",
 *     vmImage: {
 *         project: "deeplearning-platform-release",
 *         imageFamily: "tf-latest-cpu",
 *     },
 *     desiredState: "STOPPED",
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * instance = gcp.notebooks.Instance("instance",
 *     name="notebooks-instance",
 *     location="us-west1-a",
 *     machine_type="e2-medium",
 *     vm_image=gcp.notebooks.InstanceVmImageArgs(
 *         project="deeplearning-platform-release",
 *         image_family="tf-latest-cpu",
 *     ),
 *     desired_state="STOPPED")
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var instance = new Gcp.Notebooks.Instance("instance", new()
 *     {
 *         Name = "notebooks-instance",
 *         Location = "us-west1-a",
 *         MachineType = "e2-medium",
 *         VmImage = new Gcp.Notebooks.Inputs.InstanceVmImageArgs
 *         {
 *             Project = "deeplearning-platform-release",
 *             ImageFamily = "tf-latest-cpu",
 *         },
 *         DesiredState = "STOPPED",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/notebooks"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := notebooks.NewInstance(ctx, "instance", ¬ebooks.InstanceArgs{
 * 			Name:        pulumi.String("notebooks-instance"),
 * 			Location:    pulumi.String("us-west1-a"),
 * 			MachineType: pulumi.String("e2-medium"),
 * 			VmImage: ¬ebooks.InstanceVmImageArgs{
 * 				Project:     pulumi.String("deeplearning-platform-release"),
 * 				ImageFamily: pulumi.String("tf-latest-cpu"),
 * 			},
 * 			DesiredState: pulumi.String("STOPPED"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.notebooks.Instance;
 * import com.pulumi.gcp.notebooks.InstanceArgs;
 * import com.pulumi.gcp.notebooks.inputs.InstanceVmImageArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var instance = new Instance("instance", InstanceArgs.builder()
 *             .name("notebooks-instance")
 *             .location("us-west1-a")
 *             .machineType("e2-medium")
 *             .vmImage(InstanceVmImageArgs.builder()
 *                 .project("deeplearning-platform-release")
 *                 .imageFamily("tf-latest-cpu")
 *                 .build())
 *             .desiredState("STOPPED")
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   instance:
 *     type: gcp:notebooks:Instance
 *     properties:
 *       name: notebooks-instance
 *       location: us-west1-a
 *       machineType: e2-medium
 *       vmImage:
 *         project: deeplearning-platform-release
 *         imageFamily: tf-latest-cpu
 *       desiredState: STOPPED
 * ```
 * 
 * ### Notebook Instance Basic Container
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const instance = new gcp.notebooks.Instance("instance", {
 *     name: "notebooks-instance",
 *     location: "us-west1-a",
 *     machineType: "e2-medium",
 *     metadata: {
 *         "proxy-mode": "service_account",
 *     },
 *     containerImage: {
 *         repository: "gcr.io/deeplearning-platform-release/base-cpu",
 *         tag: "latest",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * instance = gcp.notebooks.Instance("instance",
 *     name="notebooks-instance",
 *     location="us-west1-a",
 *     machine_type="e2-medium",
 *     metadata={
 *         "proxy-mode": "service_account",
 *     },
 *     container_image=gcp.notebooks.InstanceContainerImageArgs(
 *         repository="gcr.io/deeplearning-platform-release/base-cpu",
 *         tag="latest",
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var instance = new Gcp.Notebooks.Instance("instance", new()
 *     {
 *         Name = "notebooks-instance",
 *         Location = "us-west1-a",
 *         MachineType = "e2-medium",
 *         Metadata =
 *         {
 *             { "proxy-mode", "service_account" },
 *         },
 *         ContainerImage = new Gcp.Notebooks.Inputs.InstanceContainerImageArgs
 *         {
 *             Repository = "gcr.io/deeplearning-platform-release/base-cpu",
 *             Tag = "latest",
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/notebooks"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := notebooks.NewInstance(ctx, "instance", ¬ebooks.InstanceArgs{
 * 			Name:        pulumi.String("notebooks-instance"),
 * 			Location:    pulumi.String("us-west1-a"),
 * 			MachineType: pulumi.String("e2-medium"),
 * 			Metadata: pulumi.StringMap{
 * 				"proxy-mode": pulumi.String("service_account"),
 * 			},
 * 			ContainerImage: ¬ebooks.InstanceContainerImageArgs{
 * 				Repository: pulumi.String("gcr.io/deeplearning-platform-release/base-cpu"),
 * 				Tag:        pulumi.String("latest"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.notebooks.Instance;
 * import com.pulumi.gcp.notebooks.InstanceArgs;
 * import com.pulumi.gcp.notebooks.inputs.InstanceContainerImageArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var instance = new Instance("instance", InstanceArgs.builder()
 *             .name("notebooks-instance")
 *             .location("us-west1-a")
 *             .machineType("e2-medium")
 *             .metadata(Map.of("proxy-mode", "service_account"))
 *             .containerImage(InstanceContainerImageArgs.builder()
 *                 .repository("gcr.io/deeplearning-platform-release/base-cpu")
 *                 .tag("latest")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   instance:
 *     type: gcp:notebooks:Instance
 *     properties:
 *       name: notebooks-instance
 *       location: us-west1-a
 *       machineType: e2-medium
 *       metadata:
 *         proxy-mode: service_account
 *       containerImage:
 *         repository: gcr.io/deeplearning-platform-release/base-cpu
 *         tag: latest
 * ```
 * 
 * ### Notebook Instance Basic Gpu
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const instance = new gcp.notebooks.Instance("instance", {
 *     name: "notebooks-instance",
 *     location: "us-west1-a",
 *     machineType: "n1-standard-1",
 *     installGpuDriver: true,
 *     acceleratorConfig: {
 *         type: "NVIDIA_TESLA_T4",
 *         coreCount: 1,
 *     },
 *     vmImage: {
 *         project: "deeplearning-platform-release",
 *         imageFamily: "tf-latest-gpu",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * instance = gcp.notebooks.Instance("instance",
 *     name="notebooks-instance",
 *     location="us-west1-a",
 *     machine_type="n1-standard-1",
 *     install_gpu_driver=True,
 *     accelerator_config=gcp.notebooks.InstanceAcceleratorConfigArgs(
 *         type="NVIDIA_TESLA_T4",
 *         core_count=1,
 *     ),
 *     vm_image=gcp.notebooks.InstanceVmImageArgs(
 *         project="deeplearning-platform-release",
 *         image_family="tf-latest-gpu",
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var instance = new Gcp.Notebooks.Instance("instance", new()
 *     {
 *         Name = "notebooks-instance",
 *         Location = "us-west1-a",
 *         MachineType = "n1-standard-1",
 *         InstallGpuDriver = true,
 *         AcceleratorConfig = new Gcp.Notebooks.Inputs.InstanceAcceleratorConfigArgs
 *         {
 *             Type = "NVIDIA_TESLA_T4",
 *             CoreCount = 1,
 *         },
 *         VmImage = new Gcp.Notebooks.Inputs.InstanceVmImageArgs
 *         {
 *             Project = "deeplearning-platform-release",
 *             ImageFamily = "tf-latest-gpu",
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/notebooks"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := notebooks.NewInstance(ctx, "instance", ¬ebooks.InstanceArgs{
 * 			Name:             pulumi.String("notebooks-instance"),
 * 			Location:         pulumi.String("us-west1-a"),
 * 			MachineType:      pulumi.String("n1-standard-1"),
 * 			InstallGpuDriver: pulumi.Bool(true),
 * 			AcceleratorConfig: ¬ebooks.InstanceAcceleratorConfigArgs{
 * 				Type:      pulumi.String("NVIDIA_TESLA_T4"),
 * 				CoreCount: pulumi.Int(1),
 * 			},
 * 			VmImage: ¬ebooks.InstanceVmImageArgs{
 * 				Project:     pulumi.String("deeplearning-platform-release"),
 * 				ImageFamily: pulumi.String("tf-latest-gpu"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.notebooks.Instance;
 * import com.pulumi.gcp.notebooks.InstanceArgs;
 * import com.pulumi.gcp.notebooks.inputs.InstanceAcceleratorConfigArgs;
 * import com.pulumi.gcp.notebooks.inputs.InstanceVmImageArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var instance = new Instance("instance", InstanceArgs.builder()
 *             .name("notebooks-instance")
 *             .location("us-west1-a")
 *             .machineType("n1-standard-1")
 *             .installGpuDriver(true)
 *             .acceleratorConfig(InstanceAcceleratorConfigArgs.builder()
 *                 .type("NVIDIA_TESLA_T4")
 *                 .coreCount(1)
 *                 .build())
 *             .vmImage(InstanceVmImageArgs.builder()
 *                 .project("deeplearning-platform-release")
 *                 .imageFamily("tf-latest-gpu")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   instance:
 *     type: gcp:notebooks:Instance
 *     properties:
 *       name: notebooks-instance
 *       location: us-west1-a
 *       machineType: n1-standard-1
 *       installGpuDriver: true
 *       acceleratorConfig:
 *         type: NVIDIA_TESLA_T4
 *         coreCount: 1
 *       vmImage:
 *         project: deeplearning-platform-release
 *         imageFamily: tf-latest-gpu
 * ```
 * 
 * ### Notebook Instance Full
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const myNetwork = gcp.compute.getNetwork({
 *     name: "default",
 * });
 * const mySubnetwork = gcp.compute.getSubnetwork({
 *     name: "default",
 *     region: "us-central1",
 * });
 * const instance = new gcp.notebooks.Instance("instance", {
 *     name: "notebooks-instance",
 *     location: "us-central1-a",
 *     machineType: "e2-medium",
 *     vmImage: {
 *         project: "deeplearning-platform-release",
 *         imageFamily: "tf-latest-cpu",
 *     },
 *     instanceOwners: ["my@service-account.com"],
 *     serviceAccount: "[email protected]",
 *     installGpuDriver: true,
 *     bootDiskType: "PD_SSD",
 *     bootDiskSizeGb: 110,
 *     noPublicIp: true,
 *     noProxyAccess: true,
 *     network: myNetwork.then(myNetwork => myNetwork.id),
 *     subnet: mySubnetwork.then(mySubnetwork => mySubnetwork.id),
 *     labels: {
 *         k: "val",
 *     },
 *     metadata: {
 *         terraform: "true",
 *     },
 *     serviceAccountScopes: [
 *         "https://www.googleapis.com/auth/bigquery",
 *         "https://www.googleapis.com/auth/devstorage.read_write",
 *         "https://www.googleapis.com/auth/cloud-platform",
 *         "https://www.googleapis.com/auth/userinfo.email",
 *     ],
 *     tags: [
 *         "foo",
 *         "bar",
 *     ],
 *     diskEncryption: "CMEK",
 *     kmsKey: "my-crypto-key",
 *     desiredState: "ACTIVE",
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * my_network = gcp.compute.get_network(name="default")
 * my_subnetwork = gcp.compute.get_subnetwork(name="default",
 *     region="us-central1")
 * instance = gcp.notebooks.Instance("instance",
 *     name="notebooks-instance",
 *     location="us-central1-a",
 *     machine_type="e2-medium",
 *     vm_image=gcp.notebooks.InstanceVmImageArgs(
 *         project="deeplearning-platform-release",
 *         image_family="tf-latest-cpu",
 *     ),
 *     instance_owners=["my@service-account.com"],
 *     service_account="[email protected]",
 *     install_gpu_driver=True,
 *     boot_disk_type="PD_SSD",
 *     boot_disk_size_gb=110,
 *     no_public_ip=True,
 *     no_proxy_access=True,
 *     network=my_network.id,
 *     subnet=my_subnetwork.id,
 *     labels={
 *         "k": "val",
 *     },
 *     metadata={
 *         "terraform": "true",
 *     },
 *     service_account_scopes=[
 *         "https://www.googleapis.com/auth/bigquery",
 *         "https://www.googleapis.com/auth/devstorage.read_write",
 *         "https://www.googleapis.com/auth/cloud-platform",
 *         "https://www.googleapis.com/auth/userinfo.email",
 *     ],
 *     tags=[
 *         "foo",
 *         "bar",
 *     ],
 *     disk_encryption="CMEK",
 *     kms_key="my-crypto-key",
 *     desired_state="ACTIVE")
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var myNetwork = Gcp.Compute.GetNetwork.Invoke(new()
 *     {
 *         Name = "default",
 *     });
 *     var mySubnetwork = Gcp.Compute.GetSubnetwork.Invoke(new()
 *     {
 *         Name = "default",
 *         Region = "us-central1",
 *     });
 *     var instance = new Gcp.Notebooks.Instance("instance", new()
 *     {
 *         Name = "notebooks-instance",
 *         Location = "us-central1-a",
 *         MachineType = "e2-medium",
 *         VmImage = new Gcp.Notebooks.Inputs.InstanceVmImageArgs
 *         {
 *             Project = "deeplearning-platform-release",
 *             ImageFamily = "tf-latest-cpu",
 *         },
 *         InstanceOwners = new[]
 *         {
 *             "[email protected]",
 *         },
 *         ServiceAccount = "[email protected]",
 *         InstallGpuDriver = true,
 *         BootDiskType = "PD_SSD",
 *         BootDiskSizeGb = 110,
 *         NoPublicIp = true,
 *         NoProxyAccess = true,
 *         Network = myNetwork.Apply(getNetworkResult => getNetworkResult.Id),
 *         Subnet = mySubnetwork.Apply(getSubnetworkResult => getSubnetworkResult.Id),
 *         Labels =
 *         {
 *             { "k", "val" },
 *         },
 *         Metadata =
 *         {
 *             { "terraform", "true" },
 *         },
 *         ServiceAccountScopes = new[]
 *         {
 *             "https://www.googleapis.com/auth/bigquery",
 *             "https://www.googleapis.com/auth/devstorage.read_write",
 *             "https://www.googleapis.com/auth/cloud-platform",
 *             "https://www.googleapis.com/auth/userinfo.email",
 *         },
 *         Tags = new[]
 *         {
 *             "foo",
 *             "bar",
 *         },
 *         DiskEncryption = "CMEK",
 *         KmsKey = "my-crypto-key",
 *         DesiredState = "ACTIVE",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/notebooks"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		myNetwork, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
 * 			Name: "default",
 * 		}, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		mySubnetwork, err := compute.LookupSubnetwork(ctx, &compute.LookupSubnetworkArgs{
 * 			Name:   pulumi.StringRef("default"),
 * 			Region: pulumi.StringRef("us-central1"),
 * 		}, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = notebooks.NewInstance(ctx, "instance", ¬ebooks.InstanceArgs{
 * 			Name:        pulumi.String("notebooks-instance"),
 * 			Location:    pulumi.String("us-central1-a"),
 * 			MachineType: pulumi.String("e2-medium"),
 * 			VmImage: ¬ebooks.InstanceVmImageArgs{
 * 				Project:     pulumi.String("deeplearning-platform-release"),
 * 				ImageFamily: pulumi.String("tf-latest-cpu"),
 * 			},
 * 			InstanceOwners: pulumi.StringArray{
 * 				pulumi.String("[email protected]"),
 * 			},
 * 			ServiceAccount:   pulumi.String("[email protected]"),
 * 			InstallGpuDriver: pulumi.Bool(true),
 * 			BootDiskType:     pulumi.String("PD_SSD"),
 * 			BootDiskSizeGb:   pulumi.Int(110),
 * 			NoPublicIp:       pulumi.Bool(true),
 * 			NoProxyAccess:    pulumi.Bool(true),
 * 			Network:          pulumi.String(myNetwork.Id),
 * 			Subnet:           pulumi.String(mySubnetwork.Id),
 * 			Labels: pulumi.StringMap{
 * 				"k": pulumi.String("val"),
 * 			},
 * 			Metadata: pulumi.StringMap{
 * 				"terraform": pulumi.String("true"),
 * 			},
 * 			ServiceAccountScopes: pulumi.StringArray{
 * 				pulumi.String("https://www.googleapis.com/auth/bigquery"),
 * 				pulumi.String("https://www.googleapis.com/auth/devstorage.read_write"),
 * 				pulumi.String("https://www.googleapis.com/auth/cloud-platform"),
 * 				pulumi.String("https://www.googleapis.com/auth/userinfo.email"),
 * 			},
 * 			Tags: pulumi.StringArray{
 * 				pulumi.String("foo"),
 * 				pulumi.String("bar"),
 * 			},
 * 			DiskEncryption: pulumi.String("CMEK"),
 * 			KmsKey:         pulumi.String("my-crypto-key"),
 * 			DesiredState:   pulumi.String("ACTIVE"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.compute.ComputeFunctions;
 * import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
 * import com.pulumi.gcp.compute.inputs.GetSubnetworkArgs;
 * import com.pulumi.gcp.notebooks.Instance;
 * import com.pulumi.gcp.notebooks.InstanceArgs;
 * import com.pulumi.gcp.notebooks.inputs.InstanceVmImageArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         final var myNetwork = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
 *             .name("default")
 *             .build());
 *         final var mySubnetwork = ComputeFunctions.getSubnetwork(GetSubnetworkArgs.builder()
 *             .name("default")
 *             .region("us-central1")
 *             .build());
 *         var instance = new Instance("instance", InstanceArgs.builder()
 *             .name("notebooks-instance")
 *             .location("us-central1-a")
 *             .machineType("e2-medium")
 *             .vmImage(InstanceVmImageArgs.builder()
 *                 .project("deeplearning-platform-release")
 *                 .imageFamily("tf-latest-cpu")
 *                 .build())
 *             .instanceOwners("[email protected]")
 *             .serviceAccount("[email protected]")
 *             .installGpuDriver(true)
 *             .bootDiskType("PD_SSD")
 *             .bootDiskSizeGb(110)
 *             .noPublicIp(true)
 *             .noProxyAccess(true)
 *             .network(myNetwork.applyValue(getNetworkResult -> getNetworkResult.id()))
 *             .subnet(mySubnetwork.applyValue(getSubnetworkResult -> getSubnetworkResult.id()))
 *             .labels(Map.of("k", "val"))
 *             .metadata(Map.of("terraform", "true"))
 *             .serviceAccountScopes(
 *                 "https://www.googleapis.com/auth/bigquery",
 *                 "https://www.googleapis.com/auth/devstorage.read_write",
 *                 "https://www.googleapis.com/auth/cloud-platform",
 *                 "https://www.googleapis.com/auth/userinfo.email")
 *             .tags(
 *                 "foo",
 *                 "bar")
 *             .diskEncryption("CMEK")
 *             .kmsKey("my-crypto-key")
 *             .desiredState("ACTIVE")
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   instance:
 *     type: gcp:notebooks:Instance
 *     properties:
 *       name: notebooks-instance
 *       location: us-central1-a
 *       machineType: e2-medium
 *       vmImage:
 *         project: deeplearning-platform-release
 *         imageFamily: tf-latest-cpu
 *       instanceOwners:
 *         - [email protected]
 *       serviceAccount: [email protected]
 *       installGpuDriver: true
 *       bootDiskType: PD_SSD
 *       bootDiskSizeGb: 110
 *       noPublicIp: true
 *       noProxyAccess: true
 *       network: ${myNetwork.id}
 *       subnet: ${mySubnetwork.id}
 *       labels:
 *         k: val
 *       metadata:
 *         terraform: 'true'
 *       serviceAccountScopes:
 *         - https://www.googleapis.com/auth/bigquery
 *         - https://www.googleapis.com/auth/devstorage.read_write
 *         - https://www.googleapis.com/auth/cloud-platform
 *         - https://www.googleapis.com/auth/userinfo.email
 *       tags:
 *         - foo
 *         - bar
 *       diskEncryption: CMEK
 *       kmsKey: my-crypto-key
 *       desiredState: ACTIVE
 * variables:
 *   myNetwork:
 *     fn::invoke:
 *       Function: gcp:compute:getNetwork
 *       Arguments:
 *         name: default
 *   mySubnetwork:
 *     fn::invoke:
 *       Function: gcp:compute:getSubnetwork
 *       Arguments:
 *         name: default
 *         region: us-central1
 * ```
 * 
 * ## Import
 * Instance can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{location}}/instances/{{name}}`
 * * `{{project}}/{{location}}/{{name}}`
 * * `{{location}}/{{name}}`
 * When using the `pulumi import` command, Instance can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:notebooks/instance:Instance default projects/{{project}}/locations/{{location}}/instances/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:notebooks/instance:Instance default {{project}}/{{location}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:notebooks/instance:Instance default {{location}}/{{name}}
 * ```
 * @property acceleratorConfig The hardware accelerator used on this instance. If you use accelerators,
 * make sure that your configuration has enough vCPUs and memory to support the
 * machineType you have selected.
 * Structure is documented below.
 * @property bootDiskSizeGb The size of the boot disk in GB attached to this instance,
 * up to a maximum of 64000 GB (64 TB). The minimum recommended value is 100 GB.
 * If not specified, this defaults to 100.
 * @property bootDiskType Possible disk types for notebook instances.
 * Possible values are: `DISK_TYPE_UNSPECIFIED`, `PD_STANDARD`, `PD_SSD`, `PD_BALANCED`, `PD_EXTREME`.
 * @property containerImage Use a container image to start the notebook instance.
 * Structure is documented below.
 * @property createTime Instance creation time
 * @property customGpuDriverPath Specify a custom Cloud Storage path where the GPU driver is stored.
 * If not specified, we'll automatically choose from official GPU drivers.
 * @property dataDiskSizeGb The size of the data disk in GB attached to this instance,
 * up to a maximum of 64000 GB (64 TB).
 * You can choose the size of the data disk based on how big your notebooks and data are.
 * If not specified, this defaults to 100.
 * @property dataDiskType Possible disk types for notebook instances.
 * Possible values are: `DISK_TYPE_UNSPECIFIED`, `PD_STANDARD`, `PD_SSD`, `PD_BALANCED`, `PD_EXTREME`.
 * @property desiredState Desired state of the Notebook Instance. Set this field to `ACTIVE` to start the Instance, and `STOPPED` to stop the Instance.
 * @property diskEncryption Disk encryption method used on the boot and data disks, defaults to GMEK.
 * Possible values are: `DISK_ENCRYPTION_UNSPECIFIED`, `GMEK`, `CMEK`.
 * @property installGpuDriver 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.
 * @property instanceOwners The list of owners of this instance after creation.
 * Format: [email protected].
 * Currently supports one owner only.
 * If not specified, all of the service account users of
 * your VM instance's service account can use the instance.
 * @property kmsKey The KMS key used to encrypt the disks, only applicable if diskEncryption is CMEK.
 * Format: projects/{project_id}/locations/{location}/keyRings/{key_ring_id}/cryptoKeys/{key_id}
 * @property labels Labels to apply to this instance. These can be later modified by the setLabels method.
 * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
 * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
 * Please refer to the field `effective_labels` for all of the labels present on the resource.
 * @property location A reference to the zone where the machine resides.
 * - - -
 * @property machineType A reference to a machine type which defines VM kind.
 * @property metadata Custom metadata to apply to this instance.
 * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
 * @property name The name specified for the Notebook instance.
 * @property network The name of the VPC that this instance is in.
 * Format: projects/{project_id}/global/networks/{network_id}
 * @property nicType The type of vNIC driver.
 * Possible values are: `UNSPECIFIED_NIC_TYPE`, `VIRTIO_NET`, `GVNIC`.
 * @property noProxyAccess The notebook instance will not register with the proxy..
 * @property noPublicIp No public IP will be assigned to this instance.
 * @property noRemoveDataDisk If true, the data disk will not be auto deleted when deleting the instance.
 * @property postStartupScript 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).
 * @property project The ID of the project in which the resource belongs.
 * If it is not provided, the provider project is used.
 * @property reservationAffinity Reservation Affinity for consuming Zonal reservation.
 * Structure is documented below.
 * @property serviceAccount 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 is used.
 * @property serviceAccountScopes Optional. The URIs of service account scopes to be included in Compute Engine instances.
 * If not specified, the following scopes are defined:
 * - https://www.googleapis.com/auth/cloud-platform
 * - https://www.googleapis.com/auth/userinfo.email
 * @property shieldedInstanceConfig A set of Shielded Instance options. Check [Images using supported Shielded VM features]
 * Not all combinations are valid
 * Structure is documented below.
 * @property subnet The name of the subnet that this instance is in.
 * Format: projects/{project_id}/regions/{region}/subnetworks/{subnetwork_id}
 * @property tags The Compute Engine tags to add to instance.
 * @property updateTime Instance update time.
 * @property vmImage Use a Compute Engine VM image to start the notebook instance.
 * Structure is documented below.
 */
public data class InstanceArgs(
    public val acceleratorConfig: Output? = null,
    public val bootDiskSizeGb: Output? = null,
    public val bootDiskType: Output? = null,
    public val containerImage: Output? = null,
    public val createTime: Output? = null,
    public val customGpuDriverPath: Output? = null,
    public val dataDiskSizeGb: Output? = null,
    public val dataDiskType: Output? = null,
    public val desiredState: Output? = null,
    public val diskEncryption: Output? = null,
    public val installGpuDriver: Output? = null,
    public val instanceOwners: Output>? = null,
    public val kmsKey: Output? = null,
    public val labels: Output>? = null,
    public val location: Output? = null,
    public val machineType: Output? = null,
    public val metadata: Output>? = null,
    public val name: Output? = null,
    public val network: Output? = null,
    public val nicType: Output? = null,
    public val noProxyAccess: Output? = null,
    public val noPublicIp: Output? = null,
    public val noRemoveDataDisk: Output? = null,
    public val postStartupScript: Output? = null,
    public val project: Output? = null,
    public val reservationAffinity: Output? = null,
    public val serviceAccount: Output? = null,
    public val serviceAccountScopes: Output>? = null,
    public val shieldedInstanceConfig: Output? = null,
    public val subnet: Output? = null,
    public val tags: Output>? = null,
    public val updateTime: Output? = null,
    public val vmImage: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.notebooks.InstanceArgs =
        com.pulumi.gcp.notebooks.InstanceArgs.builder()
            .acceleratorConfig(acceleratorConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .bootDiskSizeGb(bootDiskSizeGb?.applyValue({ args0 -> args0 }))
            .bootDiskType(bootDiskType?.applyValue({ args0 -> args0 }))
            .containerImage(containerImage?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .createTime(createTime?.applyValue({ args0 -> args0 }))
            .customGpuDriverPath(customGpuDriverPath?.applyValue({ args0 -> args0 }))
            .dataDiskSizeGb(dataDiskSizeGb?.applyValue({ args0 -> args0 }))
            .dataDiskType(dataDiskType?.applyValue({ args0 -> args0 }))
            .desiredState(desiredState?.applyValue({ args0 -> args0 }))
            .diskEncryption(diskEncryption?.applyValue({ args0 -> args0 }))
            .installGpuDriver(installGpuDriver?.applyValue({ args0 -> args0 }))
            .instanceOwners(instanceOwners?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .kmsKey(kmsKey?.applyValue({ args0 -> args0 }))
            .labels(labels?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .location(location?.applyValue({ args0 -> args0 }))
            .machineType(machineType?.applyValue({ args0 -> args0 }))
            .metadata(
                metadata?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.key.to(args0.value)
                    }).toMap()
                }),
            )
            .name(name?.applyValue({ args0 -> args0 }))
            .network(network?.applyValue({ args0 -> args0 }))
            .nicType(nicType?.applyValue({ args0 -> args0 }))
            .noProxyAccess(noProxyAccess?.applyValue({ args0 -> args0 }))
            .noPublicIp(noPublicIp?.applyValue({ args0 -> args0 }))
            .noRemoveDataDisk(noRemoveDataDisk?.applyValue({ args0 -> args0 }))
            .postStartupScript(postStartupScript?.applyValue({ args0 -> args0 }))
            .project(project?.applyValue({ args0 -> args0 }))
            .reservationAffinity(
                reservationAffinity?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .serviceAccount(serviceAccount?.applyValue({ args0 -> args0 }))
            .serviceAccountScopes(serviceAccountScopes?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .shieldedInstanceConfig(
                shieldedInstanceConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .subnet(subnet?.applyValue({ args0 -> args0 }))
            .tags(tags?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .updateTime(updateTime?.applyValue({ args0 -> args0 }))
            .vmImage(vmImage?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) })).build()
}

/**
 * Builder for [InstanceArgs].
 */
@PulumiTagMarker
public class InstanceArgsBuilder internal constructor() {
    private var acceleratorConfig: Output? = null

    private var bootDiskSizeGb: Output? = null

    private var bootDiskType: Output? = null

    private var containerImage: Output? = null

    private var createTime: Output? = null

    private var customGpuDriverPath: Output? = null

    private var dataDiskSizeGb: Output? = null

    private var dataDiskType: Output? = null

    private var desiredState: Output? = null

    private var diskEncryption: Output? = null

    private var installGpuDriver: Output? = null

    private var instanceOwners: Output>? = null

    private var kmsKey: Output? = null

    private var labels: Output>? = null

    private var location: Output? = null

    private var machineType: Output? = null

    private var metadata: Output>? = null

    private var name: Output? = null

    private var network: Output? = null

    private var nicType: Output? = null

    private var noProxyAccess: Output? = null

    private var noPublicIp: Output? = null

    private var noRemoveDataDisk: Output? = null

    private var postStartupScript: Output? = null

    private var project: Output? = null

    private var reservationAffinity: Output? = null

    private var serviceAccount: Output? = null

    private var serviceAccountScopes: Output>? = null

    private var shieldedInstanceConfig: Output? = null

    private var subnet: Output? = null

    private var tags: Output>? = null

    private var updateTime: Output? = null

    private var vmImage: Output? = null

    /**
     * @param value The hardware accelerator used on this instance. If you use accelerators,
     * make sure that your configuration has enough vCPUs and memory to support the
     * machineType you have selected.
     * Structure is documented below.
     */
    @JvmName("apnucryuydjoswrp")
    public suspend fun acceleratorConfig(`value`: Output) {
        this.acceleratorConfig = value
    }

    /**
     * @param value The size of the boot disk in GB attached to this instance,
     * up to a maximum of 64000 GB (64 TB). The minimum recommended value is 100 GB.
     * If not specified, this defaults to 100.
     */
    @JvmName("tsxonncufsykwdhw")
    public suspend fun bootDiskSizeGb(`value`: Output) {
        this.bootDiskSizeGb = value
    }

    /**
     * @param value Possible disk types for notebook instances.
     * Possible values are: `DISK_TYPE_UNSPECIFIED`, `PD_STANDARD`, `PD_SSD`, `PD_BALANCED`, `PD_EXTREME`.
     */
    @JvmName("crgsqjnreexgidwn")
    public suspend fun bootDiskType(`value`: Output) {
        this.bootDiskType = value
    }

    /**
     * @param value Use a container image to start the notebook instance.
     * Structure is documented below.
     */
    @JvmName("rgshpjsrjpxymdkk")
    public suspend fun containerImage(`value`: Output) {
        this.containerImage = value
    }

    /**
     * @param value Instance creation time
     */
    @JvmName("fmawhlqravnhowtr")
    public suspend fun createTime(`value`: Output) {
        this.createTime = value
    }

    /**
     * @param value Specify a custom Cloud Storage path where the GPU driver is stored.
     * If not specified, we'll automatically choose from official GPU drivers.
     */
    @JvmName("mxlmmvvopfwkowkx")
    public suspend fun customGpuDriverPath(`value`: Output) {
        this.customGpuDriverPath = value
    }

    /**
     * @param value The size of the data disk in GB attached to this instance,
     * up to a maximum of 64000 GB (64 TB).
     * You can choose the size of the data disk based on how big your notebooks and data are.
     * If not specified, this defaults to 100.
     */
    @JvmName("xhsskgcvyyetgoaq")
    public suspend fun dataDiskSizeGb(`value`: Output) {
        this.dataDiskSizeGb = value
    }

    /**
     * @param value Possible disk types for notebook instances.
     * Possible values are: `DISK_TYPE_UNSPECIFIED`, `PD_STANDARD`, `PD_SSD`, `PD_BALANCED`, `PD_EXTREME`.
     */
    @JvmName("exgwdmdrjjvbnkbb")
    public suspend fun dataDiskType(`value`: Output) {
        this.dataDiskType = value
    }

    /**
     * @param value Desired state of the Notebook Instance. Set this field to `ACTIVE` to start the Instance, and `STOPPED` to stop the Instance.
     */
    @JvmName("gmyuugklpupocfhy")
    public suspend fun desiredState(`value`: Output) {
        this.desiredState = value
    }

    /**
     * @param value Disk encryption method used on the boot and data disks, defaults to GMEK.
     * Possible values are: `DISK_ENCRYPTION_UNSPECIFIED`, `GMEK`, `CMEK`.
     */
    @JvmName("dallmkffnxxymwne")
    public suspend fun diskEncryption(`value`: Output) {
        this.diskEncryption = value
    }

    /**
     * @param value 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.
     */
    @JvmName("aldhjqukvyouyrfs")
    public suspend fun installGpuDriver(`value`: Output) {
        this.installGpuDriver = value
    }

    /**
     * @param value The list of owners of this instance after creation.
     * Format: [email protected].
     * Currently supports one owner only.
     * If not specified, all of the service account users of
     * your VM instance's service account can use the instance.
     */
    @JvmName("kowfjskcwyuhojqu")
    public suspend fun instanceOwners(`value`: Output>) {
        this.instanceOwners = value
    }

    @JvmName("xjgtfggcgtcdtosp")
    public suspend fun instanceOwners(vararg values: Output) {
        this.instanceOwners = Output.all(values.asList())
    }

    /**
     * @param values The list of owners of this instance after creation.
     * Format: [email protected].
     * Currently supports one owner only.
     * If not specified, all of the service account users of
     * your VM instance's service account can use the instance.
     */
    @JvmName("lyeyhbtjtsuubgds")
    public suspend fun instanceOwners(values: List>) {
        this.instanceOwners = Output.all(values)
    }

    /**
     * @param value The KMS key used to encrypt the disks, only applicable if diskEncryption is CMEK.
     * Format: projects/{project_id}/locations/{location}/keyRings/{key_ring_id}/cryptoKeys/{key_id}
     */
    @JvmName("hbkhhvdekfptxudv")
    public suspend fun kmsKey(`value`: Output) {
        this.kmsKey = value
    }

    /**
     * @param value Labels to apply to this instance. These can be later modified by the setLabels method.
     * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("aeujhxfbmhkoqnhm")
    public suspend fun labels(`value`: Output>) {
        this.labels = value
    }

    /**
     * @param value A reference to the zone where the machine resides.
     * - - -
     */
    @JvmName("cqkhndbienqijxcn")
    public suspend fun location(`value`: Output) {
        this.location = value
    }

    /**
     * @param value A reference to a machine type which defines VM kind.
     */
    @JvmName("jmqvhufvcshsmkkr")
    public suspend fun machineType(`value`: Output) {
        this.machineType = value
    }

    /**
     * @param value Custom metadata to apply to this instance.
     * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     */
    @JvmName("rbuvhccjwngchkrb")
    public suspend fun metadata(`value`: Output>) {
        this.metadata = value
    }

    /**
     * @param value The name specified for the Notebook instance.
     */
    @JvmName("artjhiwkqevgvucv")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value The name of the VPC that this instance is in.
     * Format: projects/{project_id}/global/networks/{network_id}
     */
    @JvmName("fpbxhbqwmxwfkbkd")
    public suspend fun network(`value`: Output) {
        this.network = value
    }

    /**
     * @param value The type of vNIC driver.
     * Possible values are: `UNSPECIFIED_NIC_TYPE`, `VIRTIO_NET`, `GVNIC`.
     */
    @JvmName("gqsaghwuqmkjrmpw")
    public suspend fun nicType(`value`: Output) {
        this.nicType = value
    }

    /**
     * @param value The notebook instance will not register with the proxy..
     */
    @JvmName("xdcvdwxwwkbuimla")
    public suspend fun noProxyAccess(`value`: Output) {
        this.noProxyAccess = value
    }

    /**
     * @param value No public IP will be assigned to this instance.
     */
    @JvmName("bjuhaywvikfwphna")
    public suspend fun noPublicIp(`value`: Output) {
        this.noPublicIp = value
    }

    /**
     * @param value If true, the data disk will not be auto deleted when deleting the instance.
     */
    @JvmName("bkkhkgvqvticvomx")
    public suspend fun noRemoveDataDisk(`value`: Output) {
        this.noRemoveDataDisk = value
    }

    /**
     * @param value 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).
     */
    @JvmName("oxjqymolpbvgxfwo")
    public suspend fun postStartupScript(`value`: Output) {
        this.postStartupScript = value
    }

    /**
     * @param value The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    @JvmName("kbtqnpyiknbsdwoj")
    public suspend fun project(`value`: Output) {
        this.project = value
    }

    /**
     * @param value Reservation Affinity for consuming Zonal reservation.
     * Structure is documented below.
     */
    @JvmName("uhkufitssybqhmuf")
    public suspend fun reservationAffinity(`value`: Output) {
        this.reservationAffinity = value
    }

    /**
     * @param value 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 is used.
     */
    @JvmName("dwupmxoaewqasash")
    public suspend fun serviceAccount(`value`: Output) {
        this.serviceAccount = value
    }

    /**
     * @param value Optional. The URIs of service account scopes to be included in Compute Engine instances.
     * If not specified, the following scopes are defined:
     * - https://www.googleapis.com/auth/cloud-platform
     * - https://www.googleapis.com/auth/userinfo.email
     */
    @JvmName("hdhavrmrivvlcmpw")
    public suspend fun serviceAccountScopes(`value`: Output>) {
        this.serviceAccountScopes = value
    }

    @JvmName("hlxiwdxyvxfvshgb")
    public suspend fun serviceAccountScopes(vararg values: Output) {
        this.serviceAccountScopes = Output.all(values.asList())
    }

    /**
     * @param values Optional. The URIs of service account scopes to be included in Compute Engine instances.
     * If not specified, the following scopes are defined:
     * - https://www.googleapis.com/auth/cloud-platform
     * - https://www.googleapis.com/auth/userinfo.email
     */
    @JvmName("xqksgpyomluddwnm")
    public suspend fun serviceAccountScopes(values: List>) {
        this.serviceAccountScopes = Output.all(values)
    }

    /**
     * @param value A set of Shielded Instance options. Check [Images using supported Shielded VM features]
     * Not all combinations are valid
     * Structure is documented below.
     */
    @JvmName("bxriwlumeewitxhq")
    public suspend fun shieldedInstanceConfig(`value`: Output) {
        this.shieldedInstanceConfig = value
    }

    /**
     * @param value The name of the subnet that this instance is in.
     * Format: projects/{project_id}/regions/{region}/subnetworks/{subnetwork_id}
     */
    @JvmName("ftwfiinuputrvyhx")
    public suspend fun subnet(`value`: Output) {
        this.subnet = value
    }

    /**
     * @param value The Compute Engine tags to add to instance.
     */
    @JvmName("jvgmisbxteiswqxx")
    public suspend fun tags(`value`: Output>) {
        this.tags = value
    }

    @JvmName("pypkuladkeapyuff")
    public suspend fun tags(vararg values: Output) {
        this.tags = Output.all(values.asList())
    }

    /**
     * @param values The Compute Engine tags to add to instance.
     */
    @JvmName("ifwdaohbvnnrqyih")
    public suspend fun tags(values: List>) {
        this.tags = Output.all(values)
    }

    /**
     * @param value Instance update time.
     */
    @JvmName("advcwoglvqhjcnkr")
    public suspend fun updateTime(`value`: Output) {
        this.updateTime = value
    }

    /**
     * @param value Use a Compute Engine VM image to start the notebook instance.
     * Structure is documented below.
     */
    @JvmName("khsnuwhuhjafgssq")
    public suspend fun vmImage(`value`: Output) {
        this.vmImage = value
    }

    /**
     * @param value The hardware accelerator used on this instance. If you use accelerators,
     * make sure that your configuration has enough vCPUs and memory to support the
     * machineType you have selected.
     * Structure is documented below.
     */
    @JvmName("htvwgooysepemytm")
    public suspend fun acceleratorConfig(`value`: InstanceAcceleratorConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.acceleratorConfig = mapped
    }

    /**
     * @param argument The hardware accelerator used on this instance. If you use accelerators,
     * make sure that your configuration has enough vCPUs and memory to support the
     * machineType you have selected.
     * Structure is documented below.
     */
    @JvmName("qufxkcwfiioxdovw")
    public suspend fun acceleratorConfig(argument: suspend InstanceAcceleratorConfigArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceAcceleratorConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.acceleratorConfig = mapped
    }

    /**
     * @param value The size of the boot disk in GB attached to this instance,
     * up to a maximum of 64000 GB (64 TB). The minimum recommended value is 100 GB.
     * If not specified, this defaults to 100.
     */
    @JvmName("jriqnuiakakmuefe")
    public suspend fun bootDiskSizeGb(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.bootDiskSizeGb = mapped
    }

    /**
     * @param value Possible disk types for notebook instances.
     * Possible values are: `DISK_TYPE_UNSPECIFIED`, `PD_STANDARD`, `PD_SSD`, `PD_BALANCED`, `PD_EXTREME`.
     */
    @JvmName("wdjobohxasanaeya")
    public suspend fun bootDiskType(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.bootDiskType = mapped
    }

    /**
     * @param value Use a container image to start the notebook instance.
     * Structure is documented below.
     */
    @JvmName("rcfwpbajkxbnjwbh")
    public suspend fun containerImage(`value`: InstanceContainerImageArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.containerImage = mapped
    }

    /**
     * @param argument Use a container image to start the notebook instance.
     * Structure is documented below.
     */
    @JvmName("qemqjnpgufltdutl")
    public suspend fun containerImage(argument: suspend InstanceContainerImageArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceContainerImageArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.containerImage = mapped
    }

    /**
     * @param value Instance creation time
     */
    @JvmName("lrlcynqovatgoeju")
    public suspend fun createTime(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.createTime = mapped
    }

    /**
     * @param value Specify a custom Cloud Storage path where the GPU driver is stored.
     * If not specified, we'll automatically choose from official GPU drivers.
     */
    @JvmName("cllyhdycokbnrbog")
    public suspend fun customGpuDriverPath(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.customGpuDriverPath = mapped
    }

    /**
     * @param value The size of the data disk in GB attached to this instance,
     * up to a maximum of 64000 GB (64 TB).
     * You can choose the size of the data disk based on how big your notebooks and data are.
     * If not specified, this defaults to 100.
     */
    @JvmName("bcnoifavocrcmnni")
    public suspend fun dataDiskSizeGb(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataDiskSizeGb = mapped
    }

    /**
     * @param value Possible disk types for notebook instances.
     * Possible values are: `DISK_TYPE_UNSPECIFIED`, `PD_STANDARD`, `PD_SSD`, `PD_BALANCED`, `PD_EXTREME`.
     */
    @JvmName("pwsxtlrivdiviokp")
    public suspend fun dataDiskType(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataDiskType = mapped
    }

    /**
     * @param value Desired state of the Notebook Instance. Set this field to `ACTIVE` to start the Instance, and `STOPPED` to stop the Instance.
     */
    @JvmName("txybcwcglepfqdgl")
    public suspend fun desiredState(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.desiredState = mapped
    }

    /**
     * @param value Disk encryption method used on the boot and data disks, defaults to GMEK.
     * Possible values are: `DISK_ENCRYPTION_UNSPECIFIED`, `GMEK`, `CMEK`.
     */
    @JvmName("fgvflctvweeslmtp")
    public suspend fun diskEncryption(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.diskEncryption = mapped
    }

    /**
     * @param value 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.
     */
    @JvmName("irftjojqerxtqtuf")
    public suspend fun installGpuDriver(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.installGpuDriver = mapped
    }

    /**
     * @param value The list of owners of this instance after creation.
     * Format: [email protected].
     * Currently supports one owner only.
     * If not specified, all of the service account users of
     * your VM instance's service account can use the instance.
     */
    @JvmName("smkhlribpwktgbnt")
    public suspend fun instanceOwners(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.instanceOwners = mapped
    }

    /**
     * @param values The list of owners of this instance after creation.
     * Format: [email protected].
     * Currently supports one owner only.
     * If not specified, all of the service account users of
     * your VM instance's service account can use the instance.
     */
    @JvmName("ixaowsmcensmjxgv")
    public suspend fun instanceOwners(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.instanceOwners = mapped
    }

    /**
     * @param value The KMS key used to encrypt the disks, only applicable if diskEncryption is CMEK.
     * Format: projects/{project_id}/locations/{location}/keyRings/{key_ring_id}/cryptoKeys/{key_id}
     */
    @JvmName("gkqxosgjnlrkabog")
    public suspend fun kmsKey(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.kmsKey = mapped
    }

    /**
     * @param value Labels to apply to this instance. These can be later modified by the setLabels method.
     * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("bxepsplksfkbwonj")
    public suspend fun labels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param values Labels to apply to this instance. These can be later modified by the setLabels method.
     * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("fimvcyiwlgwnsdnq")
    public fun labels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param value A reference to the zone where the machine resides.
     * - - -
     */
    @JvmName("yvrkkxmbcyjkasfk")
    public suspend fun location(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.location = mapped
    }

    /**
     * @param value A reference to a machine type which defines VM kind.
     */
    @JvmName("fdimqloocyqswrjo")
    public suspend fun machineType(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.machineType = mapped
    }

    /**
     * @param value Custom metadata to apply to this instance.
     * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     */
    @JvmName("ppcrgbhfkleomsaf")
    public suspend fun metadata(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.metadata = mapped
    }

    /**
     * @param values Custom metadata to apply to this instance.
     * An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     */
    @JvmName("xuumkjkbasmswtxt")
    public fun metadata(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.metadata = mapped
    }

    /**
     * @param value The name specified for the Notebook instance.
     */
    @JvmName("acxpqigdvfjhynhd")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value The name of the VPC that this instance is in.
     * Format: projects/{project_id}/global/networks/{network_id}
     */
    @JvmName("pbdlednwcipkvvpt")
    public suspend fun network(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.network = mapped
    }

    /**
     * @param value The type of vNIC driver.
     * Possible values are: `UNSPECIFIED_NIC_TYPE`, `VIRTIO_NET`, `GVNIC`.
     */
    @JvmName("gfndxmllqkcefqqc")
    public suspend fun nicType(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nicType = mapped
    }

    /**
     * @param value The notebook instance will not register with the proxy..
     */
    @JvmName("fckgeiwldxdwaofx")
    public suspend fun noProxyAccess(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.noProxyAccess = mapped
    }

    /**
     * @param value No public IP will be assigned to this instance.
     */
    @JvmName("tbmysamdnbaqwdxm")
    public suspend fun noPublicIp(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.noPublicIp = mapped
    }

    /**
     * @param value If true, the data disk will not be auto deleted when deleting the instance.
     */
    @JvmName("thbcnyadghemdsfs")
    public suspend fun noRemoveDataDisk(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.noRemoveDataDisk = mapped
    }

    /**
     * @param value 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).
     */
    @JvmName("fffcvqpiqmpqklwi")
    public suspend fun postStartupScript(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.postStartupScript = mapped
    }

    /**
     * @param value The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    @JvmName("livgqgbwvcsavxav")
    public suspend fun project(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.project = mapped
    }

    /**
     * @param value Reservation Affinity for consuming Zonal reservation.
     * Structure is documented below.
     */
    @JvmName("hnlqfjvxrpcqavly")
    public suspend fun reservationAffinity(`value`: InstanceReservationAffinityArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.reservationAffinity = mapped
    }

    /**
     * @param argument Reservation Affinity for consuming Zonal reservation.
     * Structure is documented below.
     */
    @JvmName("huqqurrobpcdnhbl")
    public suspend fun reservationAffinity(argument: suspend InstanceReservationAffinityArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceReservationAffinityArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.reservationAffinity = mapped
    }

    /**
     * @param value 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 is used.
     */
    @JvmName("ehxmtqyfmeoobnni")
    public suspend fun serviceAccount(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.serviceAccount = mapped
    }

    /**
     * @param value Optional. The URIs of service account scopes to be included in Compute Engine instances.
     * If not specified, the following scopes are defined:
     * - https://www.googleapis.com/auth/cloud-platform
     * - https://www.googleapis.com/auth/userinfo.email
     */
    @JvmName("jlodxlemblsrwobk")
    public suspend fun serviceAccountScopes(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.serviceAccountScopes = mapped
    }

    /**
     * @param values Optional. The URIs of service account scopes to be included in Compute Engine instances.
     * If not specified, the following scopes are defined:
     * - https://www.googleapis.com/auth/cloud-platform
     * - https://www.googleapis.com/auth/userinfo.email
     */
    @JvmName("yulgdlgloinoywme")
    public suspend fun serviceAccountScopes(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.serviceAccountScopes = mapped
    }

    /**
     * @param value A set of Shielded Instance options. Check [Images using supported Shielded VM features]
     * Not all combinations are valid
     * Structure is documented below.
     */
    @JvmName("xtpvqhtyhhqbmgmc")
    public suspend fun shieldedInstanceConfig(`value`: InstanceShieldedInstanceConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.shieldedInstanceConfig = mapped
    }

    /**
     * @param argument A set of Shielded Instance options. Check [Images using supported Shielded VM features]
     * Not all combinations are valid
     * Structure is documented below.
     */
    @JvmName("rlfyyujpbxlchtvy")
    public suspend fun shieldedInstanceConfig(argument: suspend InstanceShieldedInstanceConfigArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceShieldedInstanceConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.shieldedInstanceConfig = mapped
    }

    /**
     * @param value The name of the subnet that this instance is in.
     * Format: projects/{project_id}/regions/{region}/subnetworks/{subnetwork_id}
     */
    @JvmName("rubpmorbpvuppywk")
    public suspend fun subnet(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.subnet = mapped
    }

    /**
     * @param value The Compute Engine tags to add to instance.
     */
    @JvmName("drxyujgceqjkjldu")
    public suspend fun tags(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.tags = mapped
    }

    /**
     * @param values The Compute Engine tags to add to instance.
     */
    @JvmName("pwjagfgcpoafwnls")
    public suspend fun tags(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.tags = mapped
    }

    /**
     * @param value Instance update time.
     */
    @JvmName("qwdsvqpuqoowdktk")
    public suspend fun updateTime(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.updateTime = mapped
    }

    /**
     * @param value Use a Compute Engine VM image to start the notebook instance.
     * Structure is documented below.
     */
    @JvmName("jftdkwdhtlhwmlly")
    public suspend fun vmImage(`value`: InstanceVmImageArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.vmImage = mapped
    }

    /**
     * @param argument Use a Compute Engine VM image to start the notebook instance.
     * Structure is documented below.
     */
    @JvmName("wlqdhnxbpapmtxkp")
    public suspend fun vmImage(argument: suspend InstanceVmImageArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceVmImageArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.vmImage = mapped
    }

    internal fun build(): InstanceArgs = InstanceArgs(
        acceleratorConfig = acceleratorConfig,
        bootDiskSizeGb = bootDiskSizeGb,
        bootDiskType = bootDiskType,
        containerImage = containerImage,
        createTime = createTime,
        customGpuDriverPath = customGpuDriverPath,
        dataDiskSizeGb = dataDiskSizeGb,
        dataDiskType = dataDiskType,
        desiredState = desiredState,
        diskEncryption = diskEncryption,
        installGpuDriver = installGpuDriver,
        instanceOwners = instanceOwners,
        kmsKey = kmsKey,
        labels = labels,
        location = location,
        machineType = machineType,
        metadata = metadata,
        name = name,
        network = network,
        nicType = nicType,
        noProxyAccess = noProxyAccess,
        noPublicIp = noPublicIp,
        noRemoveDataDisk = noRemoveDataDisk,
        postStartupScript = postStartupScript,
        project = project,
        reservationAffinity = reservationAffinity,
        serviceAccount = serviceAccount,
        serviceAccountScopes = serviceAccountScopes,
        shieldedInstanceConfig = shieldedInstanceConfig,
        subnet = subnet,
        tags = tags,
        updateTime = updateTime,
        vmImage = vmImage,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy