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

com.pulumi.gcp.container.kotlin.ClusterArgs.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.12.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.container.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.container.ClusterArgs.builder
import com.pulumi.gcp.container.kotlin.inputs.ClusterAddonsConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterAddonsConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterAuthenticatorGroupsConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterAuthenticatorGroupsConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterBinaryAuthorizationArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterBinaryAuthorizationArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterClusterAutoscalingArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterClusterAutoscalingArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterClusterTelemetryArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterClusterTelemetryArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterConfidentialNodesArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterConfidentialNodesArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterCostManagementConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterCostManagementConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterDatabaseEncryptionArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterDatabaseEncryptionArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterDefaultSnatStatusArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterDefaultSnatStatusArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterDnsConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterDnsConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterEnableK8sBetaApisArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterEnableK8sBetaApisArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterFleetArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterFleetArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterGatewayApiConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterGatewayApiConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterIdentityServiceConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterIdentityServiceConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterIpAllocationPolicyArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterIpAllocationPolicyArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterLoggingConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterLoggingConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterMaintenancePolicyArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterMaintenancePolicyArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterMasterAuthArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterMasterAuthArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterMasterAuthorizedNetworksConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterMasterAuthorizedNetworksConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterMeshCertificatesArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterMeshCertificatesArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterMonitoringConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterMonitoringConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterNetworkPolicyArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterNetworkPolicyArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodeConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodeConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodePoolArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodePoolArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodePoolAutoConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodePoolAutoConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodePoolDefaultsArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterNodePoolDefaultsArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterNotificationConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterNotificationConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterPodSecurityPolicyConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterPodSecurityPolicyConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterPrivateClusterConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterPrivateClusterConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterProtectConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterProtectConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterReleaseChannelArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterReleaseChannelArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterResourceUsageExportConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterResourceUsageExportConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterSecurityPostureConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterSecurityPostureConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterServiceExternalIpsConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterServiceExternalIpsConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterTpuConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterTpuConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterVerticalPodAutoscalingArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterVerticalPodAutoscalingArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterWorkloadAltsConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterWorkloadAltsConfigArgsBuilder
import com.pulumi.gcp.container.kotlin.inputs.ClusterWorkloadIdentityConfigArgs
import com.pulumi.gcp.container.kotlin.inputs.ClusterWorkloadIdentityConfigArgsBuilder
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

/**
 * Manages a Google Kubernetes Engine (GKE) cluster.
 * To get more information about GKE clusters, see:
 *   * [The API reference](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters)
 *   * How-to guides
 *     * [GKE overview](https://cloud.google.com/kubernetes-engine/docs/concepts/kubernetes-engine-overview)
 *     * [About cluster configuration choices](https://cloud.google.com/kubernetes-engine/docs/concepts/types-of-clusters)
 * > On version 5.0.0+ of the provider, you must explicitly set `deletion_protection = false`
 * and run `pulumi up` to write the field to state in order to destroy a cluster.
 * > All arguments and attributes (including certificate outputs) will be stored in the raw state as
 * plaintext. [Read more about secrets in state](https://www.pulumi.com/docs/intro/concepts/programming-model/#secrets).
 * ## Example Usage
 * ### With A Separately Managed Node Pool (Recommended)
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const _default = new gcp.serviceaccount.Account("default", {
 *     accountId: "service-account-id",
 *     displayName: "Service Account",
 * });
 * const primary = new gcp.container.Cluster("primary", {
 *     name: "my-gke-cluster",
 *     location: "us-central1",
 *     removeDefaultNodePool: true,
 *     initialNodeCount: 1,
 * });
 * const primaryPreemptibleNodes = new gcp.container.NodePool("primary_preemptible_nodes", {
 *     name: "my-node-pool",
 *     location: "us-central1",
 *     cluster: primary.name,
 *     nodeCount: 1,
 *     nodeConfig: {
 *         preemptible: true,
 *         machineType: "e2-medium",
 *         serviceAccount: _default.email,
 *         oauthScopes: ["https://www.googleapis.com/auth/cloud-platform"],
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * default = gcp.serviceaccount.Account("default",
 *     account_id="service-account-id",
 *     display_name="Service Account")
 * primary = gcp.container.Cluster("primary",
 *     name="my-gke-cluster",
 *     location="us-central1",
 *     remove_default_node_pool=True,
 *     initial_node_count=1)
 * primary_preemptible_nodes = gcp.container.NodePool("primary_preemptible_nodes",
 *     name="my-node-pool",
 *     location="us-central1",
 *     cluster=primary.name,
 *     node_count=1,
 *     node_config=gcp.container.NodePoolNodeConfigArgs(
 *         preemptible=True,
 *         machine_type="e2-medium",
 *         service_account=default.email,
 *         oauth_scopes=["https://www.googleapis.com/auth/cloud-platform"],
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var @default = new Gcp.ServiceAccount.Account("default", new()
 *     {
 *         AccountId = "service-account-id",
 *         DisplayName = "Service Account",
 *     });
 *     var primary = new Gcp.Container.Cluster("primary", new()
 *     {
 *         Name = "my-gke-cluster",
 *         Location = "us-central1",
 *         RemoveDefaultNodePool = true,
 *         InitialNodeCount = 1,
 *     });
 *     var primaryPreemptibleNodes = new Gcp.Container.NodePool("primary_preemptible_nodes", new()
 *     {
 *         Name = "my-node-pool",
 *         Location = "us-central1",
 *         Cluster = primary.Name,
 *         NodeCount = 1,
 *         NodeConfig = new Gcp.Container.Inputs.NodePoolNodeConfigArgs
 *         {
 *             Preemptible = true,
 *             MachineType = "e2-medium",
 *             ServiceAccount = @default.Email,
 *             OauthScopes = new[]
 *             {
 *                 "https://www.googleapis.com/auth/cloud-platform",
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/serviceaccount"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := serviceaccount.NewAccount(ctx, "default", &serviceaccount.AccountArgs{
 * 			AccountId:   pulumi.String("service-account-id"),
 * 			DisplayName: pulumi.String("Service Account"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		primary, err := container.NewCluster(ctx, "primary", &container.ClusterArgs{
 * 			Name:                  pulumi.String("my-gke-cluster"),
 * 			Location:              pulumi.String("us-central1"),
 * 			RemoveDefaultNodePool: pulumi.Bool(true),
 * 			InitialNodeCount:      pulumi.Int(1),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = container.NewNodePool(ctx, "primary_preemptible_nodes", &container.NodePoolArgs{
 * 			Name:      pulumi.String("my-node-pool"),
 * 			Location:  pulumi.String("us-central1"),
 * 			Cluster:   primary.Name,
 * 			NodeCount: pulumi.Int(1),
 * 			NodeConfig: &container.NodePoolNodeConfigArgs{
 * 				Preemptible:    pulumi.Bool(true),
 * 				MachineType:    pulumi.String("e2-medium"),
 * 				ServiceAccount: _default.Email,
 * 				OauthScopes: pulumi.StringArray{
 * 					pulumi.String("https://www.googleapis.com/auth/cloud-platform"),
 * 				},
 * 			},
 * 		})
 * 		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.serviceaccount.Account;
 * import com.pulumi.gcp.serviceaccount.AccountArgs;
 * import com.pulumi.gcp.container.Cluster;
 * import com.pulumi.gcp.container.ClusterArgs;
 * import com.pulumi.gcp.container.NodePool;
 * import com.pulumi.gcp.container.NodePoolArgs;
 * import com.pulumi.gcp.container.inputs.NodePoolNodeConfigArgs;
 * 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 default_ = new Account("default", AccountArgs.builder()
 *             .accountId("service-account-id")
 *             .displayName("Service Account")
 *             .build());
 *         var primary = new Cluster("primary", ClusterArgs.builder()
 *             .name("my-gke-cluster")
 *             .location("us-central1")
 *             .removeDefaultNodePool(true)
 *             .initialNodeCount(1)
 *             .build());
 *         var primaryPreemptibleNodes = new NodePool("primaryPreemptibleNodes", NodePoolArgs.builder()
 *             .name("my-node-pool")
 *             .location("us-central1")
 *             .cluster(primary.name())
 *             .nodeCount(1)
 *             .nodeConfig(NodePoolNodeConfigArgs.builder()
 *                 .preemptible(true)
 *                 .machineType("e2-medium")
 *                 .serviceAccount(default_.email())
 *                 .oauthScopes("https://www.googleapis.com/auth/cloud-platform")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   default:
 *     type: gcp:serviceaccount:Account
 *     properties:
 *       accountId: service-account-id
 *       displayName: Service Account
 *   primary:
 *     type: gcp:container:Cluster
 *     properties:
 *       name: my-gke-cluster
 *       location: us-central1
 *       removeDefaultNodePool: true
 *       initialNodeCount: 1
 *   primaryPreemptibleNodes:
 *     type: gcp:container:NodePool
 *     name: primary_preemptible_nodes
 *     properties:
 *       name: my-node-pool
 *       location: us-central1
 *       cluster: ${primary.name}
 *       nodeCount: 1
 *       nodeConfig:
 *         preemptible: true
 *         machineType: e2-medium
 *         serviceAccount: ${default.email}
 *         oauthScopes:
 *           - https://www.googleapis.com/auth/cloud-platform
 * ```
 * 
 * > **Note:** It is recommended that node pools be created and managed as separate resources as in the example above.
 * This allows node pools to be added and removed without recreating the cluster.  Node pools defined directly in the
 * `gcp.container.Cluster` resource cannot be removed without re-creating the cluster.
 * ### With The Default Node Pool
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const _default = new gcp.serviceaccount.Account("default", {
 *     accountId: "service-account-id",
 *     displayName: "Service Account",
 * });
 * const primary = new gcp.container.Cluster("primary", {
 *     name: "marcellus-wallace",
 *     location: "us-central1-a",
 *     initialNodeCount: 3,
 *     nodeConfig: {
 *         serviceAccount: _default.email,
 *         oauthScopes: ["https://www.googleapis.com/auth/cloud-platform"],
 *         labels: {
 *             foo: "bar",
 *         },
 *         tags: [
 *             "foo",
 *             "bar",
 *         ],
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * default = gcp.serviceaccount.Account("default",
 *     account_id="service-account-id",
 *     display_name="Service Account")
 * primary = gcp.container.Cluster("primary",
 *     name="marcellus-wallace",
 *     location="us-central1-a",
 *     initial_node_count=3,
 *     node_config=gcp.container.ClusterNodeConfigArgs(
 *         service_account=default.email,
 *         oauth_scopes=["https://www.googleapis.com/auth/cloud-platform"],
 *         labels={
 *             "foo": "bar",
 *         },
 *         tags=[
 *             "foo",
 *             "bar",
 *         ],
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var @default = new Gcp.ServiceAccount.Account("default", new()
 *     {
 *         AccountId = "service-account-id",
 *         DisplayName = "Service Account",
 *     });
 *     var primary = new Gcp.Container.Cluster("primary", new()
 *     {
 *         Name = "marcellus-wallace",
 *         Location = "us-central1-a",
 *         InitialNodeCount = 3,
 *         NodeConfig = new Gcp.Container.Inputs.ClusterNodeConfigArgs
 *         {
 *             ServiceAccount = @default.Email,
 *             OauthScopes = new[]
 *             {
 *                 "https://www.googleapis.com/auth/cloud-platform",
 *             },
 *             Labels =
 *             {
 *                 { "foo", "bar" },
 *             },
 *             Tags = new[]
 *             {
 *                 "foo",
 *                 "bar",
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/serviceaccount"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := serviceaccount.NewAccount(ctx, "default", &serviceaccount.AccountArgs{
 * 			AccountId:   pulumi.String("service-account-id"),
 * 			DisplayName: pulumi.String("Service Account"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = container.NewCluster(ctx, "primary", &container.ClusterArgs{
 * 			Name:             pulumi.String("marcellus-wallace"),
 * 			Location:         pulumi.String("us-central1-a"),
 * 			InitialNodeCount: pulumi.Int(3),
 * 			NodeConfig: &container.ClusterNodeConfigArgs{
 * 				ServiceAccount: _default.Email,
 * 				OauthScopes: pulumi.StringArray{
 * 					pulumi.String("https://www.googleapis.com/auth/cloud-platform"),
 * 				},
 * 				Labels: pulumi.StringMap{
 * 					"foo": pulumi.String("bar"),
 * 				},
 * 				Tags: pulumi.StringArray{
 * 					pulumi.String("foo"),
 * 					pulumi.String("bar"),
 * 				},
 * 			},
 * 		})
 * 		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.serviceaccount.Account;
 * import com.pulumi.gcp.serviceaccount.AccountArgs;
 * import com.pulumi.gcp.container.Cluster;
 * import com.pulumi.gcp.container.ClusterArgs;
 * import com.pulumi.gcp.container.inputs.ClusterNodeConfigArgs;
 * 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 default_ = new Account("default", AccountArgs.builder()
 *             .accountId("service-account-id")
 *             .displayName("Service Account")
 *             .build());
 *         var primary = new Cluster("primary", ClusterArgs.builder()
 *             .name("marcellus-wallace")
 *             .location("us-central1-a")
 *             .initialNodeCount(3)
 *             .nodeConfig(ClusterNodeConfigArgs.builder()
 *                 .serviceAccount(default_.email())
 *                 .oauthScopes("https://www.googleapis.com/auth/cloud-platform")
 *                 .labels(Map.of("foo", "bar"))
 *                 .tags(
 *                     "foo",
 *                     "bar")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   default:
 *     type: gcp:serviceaccount:Account
 *     properties:
 *       accountId: service-account-id
 *       displayName: Service Account
 *   primary:
 *     type: gcp:container:Cluster
 *     properties:
 *       name: marcellus-wallace
 *       location: us-central1-a
 *       initialNodeCount: 3
 *       nodeConfig:
 *         serviceAccount: ${default.email}
 *         oauthScopes:
 *           - https://www.googleapis.com/auth/cloud-platform
 *         labels:
 *           foo: bar
 *         tags:
 *           - foo
 *           - bar
 * ```
 * 
 * ### Autopilot
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const _default = new gcp.serviceaccount.Account("default", {
 *     accountId: "service-account-id",
 *     displayName: "Service Account",
 * });
 * const primary = new gcp.container.Cluster("primary", {
 *     name: "marcellus-wallace",
 *     location: "us-central1-a",
 *     enableAutopilot: true,
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * default = gcp.serviceaccount.Account("default",
 *     account_id="service-account-id",
 *     display_name="Service Account")
 * primary = gcp.container.Cluster("primary",
 *     name="marcellus-wallace",
 *     location="us-central1-a",
 *     enable_autopilot=True)
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var @default = new Gcp.ServiceAccount.Account("default", new()
 *     {
 *         AccountId = "service-account-id",
 *         DisplayName = "Service Account",
 *     });
 *     var primary = new Gcp.Container.Cluster("primary", new()
 *     {
 *         Name = "marcellus-wallace",
 *         Location = "us-central1-a",
 *         EnableAutopilot = true,
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/serviceaccount"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := serviceaccount.NewAccount(ctx, "default", &serviceaccount.AccountArgs{
 * 			AccountId:   pulumi.String("service-account-id"),
 * 			DisplayName: pulumi.String("Service Account"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = container.NewCluster(ctx, "primary", &container.ClusterArgs{
 * 			Name:            pulumi.String("marcellus-wallace"),
 * 			Location:        pulumi.String("us-central1-a"),
 * 			EnableAutopilot: pulumi.Bool(true),
 * 		})
 * 		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.serviceaccount.Account;
 * import com.pulumi.gcp.serviceaccount.AccountArgs;
 * import com.pulumi.gcp.container.Cluster;
 * import com.pulumi.gcp.container.ClusterArgs;
 * 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 default_ = new Account("default", AccountArgs.builder()
 *             .accountId("service-account-id")
 *             .displayName("Service Account")
 *             .build());
 *         var primary = new Cluster("primary", ClusterArgs.builder()
 *             .name("marcellus-wallace")
 *             .location("us-central1-a")
 *             .enableAutopilot(true)
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   default:
 *     type: gcp:serviceaccount:Account
 *     properties:
 *       accountId: service-account-id
 *       displayName: Service Account
 *   primary:
 *     type: gcp:container:Cluster
 *     properties:
 *       name: marcellus-wallace
 *       location: us-central1-a
 *       enableAutopilot: true
 * ```
 * 
 * ## Import
 * GKE clusters can be imported using the `project` , `location`, and `name`. If the project is omitted, the default
 * provider value will be used. Examples:
 * * `projects/{{project_id}}/locations/{{location}}/clusters/{{cluster_id}}`
 * * `{{project_id}}/{{location}}/{{cluster_id}}`
 * * `{{location}}/{{cluster_id}}`
 * When using the `pulumi import` command, GKE clusters can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:container/cluster:Cluster default projects/{{project_id}}/locations/{{location}}/clusters/{{cluster_id}}
 * ```
 * ```sh
 * $ pulumi import gcp:container/cluster:Cluster default {{project_id}}/{{location}}/{{cluster_id}}
 * ```
 * ```sh
 * $ pulumi import gcp:container/cluster:Cluster default {{location}}/{{cluster_id}}
 * ```
 * For example, the following fields will show diffs if set in config:
 * - `min_master_version`
 * - `remove_default_node_pool`
 * @property addonsConfig The configuration for addons supported by GKE.
 * Structure is documented below.
 * @property allowNetAdmin Enable NET_ADMIN for the cluster. Defaults to
 * `false`. This field should only be enabled for Autopilot clusters (`enable_autopilot`
 * set to `true`).
 * @property authenticatorGroupsConfig Configuration for the
 * [Google Groups for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/role-based-access-control#groups-setup-gsuite) feature.
 * Structure is documented below.
 * @property binaryAuthorization Configuration options for the Binary
 * Authorization feature. Structure is documented below.
 * @property clusterAutoscaling Per-cluster configuration of Node Auto-Provisioning with Cluster Autoscaler to
 * automatically adjust the size of the cluster and create/delete node pools based
 * on the current needs of the cluster's workload. See the
 * [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
 * for more details. Structure is documented below.
 * @property clusterIpv4Cidr The IP address range of the Kubernetes pods
 * in this cluster in CIDR notation (e.g. `10.96.0.0/14`). Leave blank to have one
 * automatically chosen or specify a `/14` block in `10.0.0.0/8`. This field will
 * default a new cluster to routes-based, where `ip_allocation_policy` is not defined.
 * @property clusterTelemetry Configuration for
 * [ClusterTelemetry](https://cloud.google.com/monitoring/kubernetes-engine/installing#controlling_the_collection_of_application_logs) feature,
 * Structure is documented below.
 * @property confidentialNodes Configuration for [Confidential Nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/confidential-gke-nodes) feature. Structure is documented below documented below.
 * @property costManagementConfig Configuration for the
 * [Cost Allocation](https://cloud.google.com/kubernetes-engine/docs/how-to/cost-allocations) feature.
 * Structure is documented below.
 * @property databaseEncryption Structure is documented below.
 * @property datapathProvider The desired datapath provider for this cluster. This is set to `LEGACY_DATAPATH` by default, which uses the IPTables-based kube-proxy implementation. Set to `ADVANCED_DATAPATH` to enable Dataplane v2.
 * @property defaultMaxPodsPerNode The default maximum number of pods
 * per node in this cluster. This doesn't work on "routes-based" clusters, clusters
 * that don't have IP Aliasing enabled. See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/how-to/flexible-pod-cidr)
 * for more information.
 * @property defaultSnatStatus [GKE SNAT](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-masquerade-agent#how_ipmasq_works) DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster, [API doc](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#networkconfig). Structure is documented below
 * @property deletionProtection
 * @property description Description of the cluster.
 * @property dnsConfig Configuration for [Using Cloud DNS for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/cloud-dns). Structure is documented below.
 * @property enableAutopilot Enable Autopilot for this cluster. Defaults to `false`.
 * Note that when this option is enabled, certain features of Standard GKE are not available.
 * See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison)
 * for available features.
 * @property enableCiliumClusterwideNetworkPolicy Whether CiliumClusterWideNetworkPolicy is enabled on this cluster. Defaults to false.
 * @property enableFqdnNetworkPolicy Whether FQDN Network Policy is enabled on this cluster. Users who enable this feature for existing Standard clusters must restart the GKE Dataplane V2 `anetd` DaemonSet after enabling it. See the [Enable FQDN Network Policy in an existing cluster](https://cloud.google.com/kubernetes-engine/docs/how-to/fqdn-network-policies#enable_fqdn_network_policy_in_an_existing_cluster) for more information.
 * @property enableIntranodeVisibility Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
 * @property enableK8sBetaApis Configuration for Kubernetes Beta APIs.
 * Structure is documented below.
 * @property enableKubernetesAlpha Whether to enable Kubernetes Alpha features for
 * this cluster. Note that when this option is enabled, the cluster cannot be upgraded
 * and will be automatically deleted after 30 days.
 * @property enableL4IlbSubsetting Whether L4ILB Subsetting is enabled for this cluster.
 * @property enableLegacyAbac Whether the ABAC authorizer is enabled for this cluster.
 * When enabled, identities in the system, including service accounts, nodes, and controllers,
 * will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
 * Defaults to `false`
 * @property enableMultiNetworking Whether multi-networking is enabled for this cluster.
 * @property enableShieldedNodes Enable Shielded Nodes features on all nodes in this cluster.  Defaults to `true`.
 * @property enableTpu Whether to enable Cloud TPU resources in this cluster.
 * See the [official documentation](https://cloud.google.com/tpu/docs/kubernetes-engine-setup).
 * @property fleet Fleet configuration for the cluster. Structure is documented below.
 * @property gatewayApiConfig Configuration for [GKE Gateway API controller](https://cloud.google.com/kubernetes-engine/docs/concepts/gateway-api). Structure is documented below.
 * @property identityServiceConfig . Structure is documented below.
 * @property initialNodeCount The number of nodes to create in this
 * cluster's default node pool. In regional or multi-zonal clusters, this is the
 * number of nodes per zone. Must be set if `node_pool` is not set. If you're using
 * `gcp.container.NodePool` objects with no default node pool, you'll need to
 * set this to a value of at least `1`, alongside setting
 * `remove_default_node_pool` to `true`.
 * @property ipAllocationPolicy Configuration of cluster IP allocation for
 * VPC-native clusters. If this block is unset during creation, it will be set by the GKE backend.
 * Structure is documented below.
 * @property location The location (region or zone) in which the cluster
 * master will be created, as well as the default node location. If you specify a
 * zone (such as `us-central1-a`), the cluster will be a zonal cluster with a
 * single cluster master. If you specify a region (such as `us-west1`), the
 * cluster will be a regional cluster with multiple masters spread across zones in
 * the region, and with default node locations in those zones as well
 * @property loggingConfig Logging configuration for the cluster.
 * Structure is documented below.
 * @property loggingService The logging service that the cluster should
 * write logs to. Available options include `logging.googleapis.com`(Legacy Stackdriver),
 * `logging.googleapis.com/kubernetes`(Stackdriver Kubernetes Engine Logging), and `none`. Defaults to `logging.googleapis.com/kubernetes`
 * @property maintenancePolicy The maintenance policy to use for the cluster. Structure is
 * documented below.
 * @property masterAuth The authentication information for accessing the
 * Kubernetes master. Some values in this block are only returned by the API if
 * your service account has permission to get credentials for your GKE cluster. If
 * you see an unexpected diff unsetting your client cert, ensure you have the
 * `container.clusters.getCredentials` permission.
 * Structure is documented below.
 * @property masterAuthorizedNetworksConfig The desired
 * configuration options for master authorized networks. Omit the
 * nested `cidr_blocks` attribute to disallow external access (except
 * the cluster node IPs, which GKE automatically whitelists).
 * Structure is documented below.
 * @property meshCertificates Structure is documented below.
 * @property minMasterVersion The minimum version of the master. GKE
 * will auto-update the master to new versions, so this does not guarantee the
 * current master version--use the read-only `master_version` field to obtain that.
 * If unset, the cluster's version will be set by GKE to the version of the most recent
 * official release (which is not necessarily the latest version).  Most users will find
 * the `gcp.container.getEngineVersions` data source useful - it indicates which versions
 * are available. If you intend to specify versions manually,
 * [the docs](https://cloud.google.com/kubernetes-engine/versioning-and-upgrades#specifying_cluster_version)
 * describe the various acceptable formats for this field.
 * > If you are using the `gcp.container.getEngineVersions` datasource with a regional cluster, ensure that you have provided a `location`
 * to the datasource. A region can have a different set of supported versions than its corresponding zones, and not all zones in a
 * region are guaranteed to support the same version.
 * @property monitoringConfig Monitoring configuration for the cluster.
 * Structure is documented below.
 * @property monitoringService The monitoring service that the cluster
 * should write metrics to.
 * Automatically send metrics from pods in the cluster to the Google Cloud Monitoring API.
 * VM metrics will be collected by Google Compute Engine regardless of this setting
 * Available options include
 * `monitoring.googleapis.com`(Legacy Stackdriver), `monitoring.googleapis.com/kubernetes`(Stackdriver Kubernetes Engine Monitoring), and `none`.
 * Defaults to `monitoring.googleapis.com/kubernetes`
 * @property name The name of the cluster, unique within the project and
 * location.
 * - - -
 * @property network The name or self_link of the Google Compute Engine
 * network to which the cluster is connected. For Shared VPC, set this to the self link of the
 * shared network.
 * @property networkPolicy Configuration options for the
 * [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/networkpolicies/)
 * feature. Structure is documented below.
 * @property networkingMode Determines whether alias IPs or routes will be used for pod IPs in the cluster.
 * Options are `VPC_NATIVE` or `ROUTES`. `VPC_NATIVE` enables [IP aliasing](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-aliases). Newly created clusters will default to `VPC_NATIVE`.
 * @property nodeConfig Parameters used in creating the default node pool.
 * Generally, this field should not be used at the same time as a
 * `gcp.container.NodePool` or a `node_pool` block; this configuration
 * manages the default node pool, which isn't recommended to be used.
 * Structure is documented below.
 * @property nodeLocations The list of zones in which the cluster's nodes
 * are located. Nodes must be in the region of their regional cluster or in the
 * same region as their cluster's zone for zonal clusters. If this is specified for
 * a zonal cluster, omit the cluster's zone.
 * > A "multi-zonal" cluster is a zonal cluster with at least one additional zone
 * defined; in a multi-zonal cluster, the cluster master is only present in a
 * single zone while nodes are present in each of the primary zone and the node
 * locations. In contrast, in a regional cluster, cluster master nodes are present
 * in multiple zones in the region. For that reason, regional clusters should be
 * preferred.
 * @property nodePoolAutoConfig Node pool configs that apply to auto-provisioned node pools in
 * [autopilot](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison) clusters and
 * [node auto-provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)-enabled clusters. Structure is documented below.
 * @property nodePoolDefaults Default NodePool settings for the entire cluster. These settings are overridden if specified on the specific NodePool object. Structure is documented below.
 * @property nodePools List of node pools associated with this cluster.
 * See gcp.container.NodePool for schema.
 * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
 * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
 * to say "these are the _only_ node pools associated with this cluster", use the
 * gcp.container.NodePool resource instead of this property.
 * @property nodeVersion The Kubernetes version on the nodes. Must either be unset
 * or set to the same value as `min_master_version` on create. Defaults to the default
 * version set by GKE which is not necessarily the latest version. This only affects
 * nodes in the default node pool. While a fuzzy version can be specified, it's
 * recommended that you specify explicit versions as the provider will see spurious diffs
 * when fuzzy versions are used. See the `gcp.container.getEngineVersions` data source's
 * `version_prefix` field to approximate fuzzy versions.
 * To update nodes in other node pools, use the `version` attribute on the node pool.
 * @property notificationConfig Configuration for the [cluster upgrade notifications](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-upgrade-notifications) feature. Structure is documented below.
 * @property podSecurityPolicyConfig Configuration for the
 * [PodSecurityPolicy](https://cloud.google.com/kubernetes-engine/docs/how-to/pod-security-policies) feature.
 * Structure is documented below.
 * @property privateClusterConfig Configuration for [private clusters](https://cloud.google.com/kubernetes-engine/docs/how-to/private-clusters),
 * clusters with private nodes. Structure is documented below.
 * @property privateIpv6GoogleAccess The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4).
 * @property project The ID of the project in which the resource belongs. If it
 * is not provided, the provider project is used.
 * @property protectConfig Enable/Disable Protect API features for the cluster. Structure is documented below.
 * @property releaseChannel Configuration options for the [Release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels)
 * feature, which provide more control over automatic upgrades of your GKE clusters.
 * When updating this field, GKE imposes specific version requirements. See
 * [Selecting a new release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels#selecting_a_new_release_channel)
 * for more details; the `gcp.container.getEngineVersions` datasource can provide
 * the default version for a channel. Note that removing the `release_channel`
 * field from your config will cause the provider to stop managing your cluster's
 * release channel, but will not unenroll it. Instead, use the `"UNSPECIFIED"`
 * channel. Structure is documented below.
 * @property removeDefaultNodePool If `true`, deletes the default node
 * pool upon cluster creation. If you're using `gcp.container.NodePool`
 * resources with no default node pool, this should be set to `true`, alongside
 * setting `initial_node_count` to at least `1`.
 * @property resourceLabels The GCE resource labels (a map of key/value pairs) to be applied to the cluster.
 * @property resourceUsageExportConfig Configuration for the
 * [ResourceUsageExportConfig](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-usage-metering) feature.
 * Structure is documented below.
 * @property securityPostureConfig Enable/Disable Security Posture API features for the cluster. Structure is documented below.
 * @property serviceExternalIpsConfig Structure is documented below.
 * @property subnetwork The name or self_link of the Google Compute Engine
 * subnetwork in which the cluster's instances are launched.
 * @property tpuConfig TPU configuration for the cluster.
 * @property verticalPodAutoscaling Vertical Pod Autoscaling automatically adjusts the resources of pods controlled by it.
 * Structure is documented below.
 * @property workloadAltsConfig Configuration for [direct-path (via ALTS) with workload identity.](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#workloadaltsconfig). Structure is documented below.
 * The `default_snat_status` block supports
 * @property workloadIdentityConfig Workload Identity allows Kubernetes service accounts to act as a user-managed
 * [Google IAM Service Account](https://cloud.google.com/iam/docs/service-accounts#user-managed_service_accounts).
 * Structure is documented below.
 */
public data class ClusterArgs(
    public val addonsConfig: Output? = null,
    public val allowNetAdmin: Output? = null,
    public val authenticatorGroupsConfig: Output? = null,
    public val binaryAuthorization: Output? = null,
    public val clusterAutoscaling: Output? = null,
    public val clusterIpv4Cidr: Output? = null,
    public val clusterTelemetry: Output? = null,
    public val confidentialNodes: Output? = null,
    public val costManagementConfig: Output? = null,
    public val databaseEncryption: Output? = null,
    public val datapathProvider: Output? = null,
    public val defaultMaxPodsPerNode: Output? = null,
    public val defaultSnatStatus: Output? = null,
    public val deletionProtection: Output? = null,
    public val description: Output? = null,
    public val dnsConfig: Output? = null,
    public val enableAutopilot: Output? = null,
    public val enableCiliumClusterwideNetworkPolicy: Output? = null,
    public val enableFqdnNetworkPolicy: Output? = null,
    public val enableIntranodeVisibility: Output? = null,
    public val enableK8sBetaApis: Output? = null,
    public val enableKubernetesAlpha: Output? = null,
    public val enableL4IlbSubsetting: Output? = null,
    public val enableLegacyAbac: Output? = null,
    public val enableMultiNetworking: Output? = null,
    public val enableShieldedNodes: Output? = null,
    public val enableTpu: Output? = null,
    public val fleet: Output? = null,
    public val gatewayApiConfig: Output? = null,
    public val identityServiceConfig: Output? = null,
    public val initialNodeCount: Output? = null,
    public val ipAllocationPolicy: Output? = null,
    public val location: Output? = null,
    public val loggingConfig: Output? = null,
    public val loggingService: Output? = null,
    public val maintenancePolicy: Output? = null,
    public val masterAuth: Output? = null,
    public val masterAuthorizedNetworksConfig: Output? =
        null,
    public val meshCertificates: Output? = null,
    public val minMasterVersion: Output? = null,
    public val monitoringConfig: Output? = null,
    public val monitoringService: Output? = null,
    public val name: Output? = null,
    public val network: Output? = null,
    public val networkPolicy: Output? = null,
    public val networkingMode: Output? = null,
    public val nodeConfig: Output? = null,
    public val nodeLocations: Output>? = null,
    public val nodePoolAutoConfig: Output? = null,
    public val nodePoolDefaults: Output? = null,
    public val nodePools: Output>? = null,
    public val nodeVersion: Output? = null,
    public val notificationConfig: Output? = null,
    public val podSecurityPolicyConfig: Output? = null,
    public val privateClusterConfig: Output? = null,
    public val privateIpv6GoogleAccess: Output? = null,
    public val project: Output? = null,
    public val protectConfig: Output? = null,
    public val releaseChannel: Output? = null,
    public val removeDefaultNodePool: Output? = null,
    public val resourceLabels: Output>? = null,
    public val resourceUsageExportConfig: Output? = null,
    public val securityPostureConfig: Output? = null,
    public val serviceExternalIpsConfig: Output? = null,
    public val subnetwork: Output? = null,
    public val tpuConfig: Output? = null,
    public val verticalPodAutoscaling: Output? = null,
    public val workloadAltsConfig: Output? = null,
    public val workloadIdentityConfig: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.container.ClusterArgs =
        com.pulumi.gcp.container.ClusterArgs.builder()
            .addonsConfig(addonsConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .allowNetAdmin(allowNetAdmin?.applyValue({ args0 -> args0 }))
            .authenticatorGroupsConfig(
                authenticatorGroupsConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .binaryAuthorization(
                binaryAuthorization?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .clusterAutoscaling(
                clusterAutoscaling?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .clusterIpv4Cidr(clusterIpv4Cidr?.applyValue({ args0 -> args0 }))
            .clusterTelemetry(clusterTelemetry?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .confidentialNodes(confidentialNodes?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .costManagementConfig(
                costManagementConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .databaseEncryption(
                databaseEncryption?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .datapathProvider(datapathProvider?.applyValue({ args0 -> args0 }))
            .defaultMaxPodsPerNode(defaultMaxPodsPerNode?.applyValue({ args0 -> args0 }))
            .defaultSnatStatus(defaultSnatStatus?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .deletionProtection(deletionProtection?.applyValue({ args0 -> args0 }))
            .description(description?.applyValue({ args0 -> args0 }))
            .dnsConfig(dnsConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .enableAutopilot(enableAutopilot?.applyValue({ args0 -> args0 }))
            .enableCiliumClusterwideNetworkPolicy(
                enableCiliumClusterwideNetworkPolicy?.applyValue({ args0 ->
                    args0
                }),
            )
            .enableFqdnNetworkPolicy(enableFqdnNetworkPolicy?.applyValue({ args0 -> args0 }))
            .enableIntranodeVisibility(enableIntranodeVisibility?.applyValue({ args0 -> args0 }))
            .enableK8sBetaApis(enableK8sBetaApis?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .enableKubernetesAlpha(enableKubernetesAlpha?.applyValue({ args0 -> args0 }))
            .enableL4IlbSubsetting(enableL4IlbSubsetting?.applyValue({ args0 -> args0 }))
            .enableLegacyAbac(enableLegacyAbac?.applyValue({ args0 -> args0 }))
            .enableMultiNetworking(enableMultiNetworking?.applyValue({ args0 -> args0 }))
            .enableShieldedNodes(enableShieldedNodes?.applyValue({ args0 -> args0 }))
            .enableTpu(enableTpu?.applyValue({ args0 -> args0 }))
            .fleet(fleet?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .gatewayApiConfig(gatewayApiConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .identityServiceConfig(
                identityServiceConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .initialNodeCount(initialNodeCount?.applyValue({ args0 -> args0 }))
            .ipAllocationPolicy(
                ipAllocationPolicy?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .location(location?.applyValue({ args0 -> args0 }))
            .loggingConfig(loggingConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .loggingService(loggingService?.applyValue({ args0 -> args0 }))
            .maintenancePolicy(maintenancePolicy?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .masterAuth(masterAuth?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .masterAuthorizedNetworksConfig(
                masterAuthorizedNetworksConfig?.applyValue({ args0 ->
                    args0.let({ args0 -> args0.toJava() })
                }),
            )
            .meshCertificates(meshCertificates?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .minMasterVersion(minMasterVersion?.applyValue({ args0 -> args0 }))
            .monitoringConfig(monitoringConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .monitoringService(monitoringService?.applyValue({ args0 -> args0 }))
            .name(name?.applyValue({ args0 -> args0 }))
            .network(network?.applyValue({ args0 -> args0 }))
            .networkPolicy(networkPolicy?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .networkingMode(networkingMode?.applyValue({ args0 -> args0 }))
            .nodeConfig(nodeConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .nodeLocations(nodeLocations?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .nodePoolAutoConfig(
                nodePoolAutoConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .nodePoolDefaults(nodePoolDefaults?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .nodePools(
                nodePools?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .nodeVersion(nodeVersion?.applyValue({ args0 -> args0 }))
            .notificationConfig(
                notificationConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .podSecurityPolicyConfig(
                podSecurityPolicyConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .privateClusterConfig(
                privateClusterConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .privateIpv6GoogleAccess(privateIpv6GoogleAccess?.applyValue({ args0 -> args0 }))
            .project(project?.applyValue({ args0 -> args0 }))
            .protectConfig(protectConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .releaseChannel(releaseChannel?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .removeDefaultNodePool(removeDefaultNodePool?.applyValue({ args0 -> args0 }))
            .resourceLabels(
                resourceLabels?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.key.to(args0.value)
                    }).toMap()
                }),
            )
            .resourceUsageExportConfig(
                resourceUsageExportConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .securityPostureConfig(
                securityPostureConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .serviceExternalIpsConfig(
                serviceExternalIpsConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .subnetwork(subnetwork?.applyValue({ args0 -> args0 }))
            .tpuConfig(tpuConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .verticalPodAutoscaling(
                verticalPodAutoscaling?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .workloadAltsConfig(
                workloadAltsConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .workloadIdentityConfig(
                workloadIdentityConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            ).build()
}

/**
 * Builder for [ClusterArgs].
 */
@PulumiTagMarker
public class ClusterArgsBuilder internal constructor() {
    private var addonsConfig: Output? = null

    private var allowNetAdmin: Output? = null

    private var authenticatorGroupsConfig: Output? = null

    private var binaryAuthorization: Output? = null

    private var clusterAutoscaling: Output? = null

    private var clusterIpv4Cidr: Output? = null

    private var clusterTelemetry: Output? = null

    private var confidentialNodes: Output? = null

    private var costManagementConfig: Output? = null

    private var databaseEncryption: Output? = null

    private var datapathProvider: Output? = null

    private var defaultMaxPodsPerNode: Output? = null

    private var defaultSnatStatus: Output? = null

    private var deletionProtection: Output? = null

    private var description: Output? = null

    private var dnsConfig: Output? = null

    private var enableAutopilot: Output? = null

    private var enableCiliumClusterwideNetworkPolicy: Output? = null

    private var enableFqdnNetworkPolicy: Output? = null

    private var enableIntranodeVisibility: Output? = null

    private var enableK8sBetaApis: Output? = null

    private var enableKubernetesAlpha: Output? = null

    private var enableL4IlbSubsetting: Output? = null

    private var enableLegacyAbac: Output? = null

    private var enableMultiNetworking: Output? = null

    private var enableShieldedNodes: Output? = null

    private var enableTpu: Output? = null

    private var fleet: Output? = null

    private var gatewayApiConfig: Output? = null

    private var identityServiceConfig: Output? = null

    private var initialNodeCount: Output? = null

    private var ipAllocationPolicy: Output? = null

    private var location: Output? = null

    private var loggingConfig: Output? = null

    private var loggingService: Output? = null

    private var maintenancePolicy: Output? = null

    private var masterAuth: Output? = null

    private var masterAuthorizedNetworksConfig: Output? =
        null

    private var meshCertificates: Output? = null

    private var minMasterVersion: Output? = null

    private var monitoringConfig: Output? = null

    private var monitoringService: Output? = null

    private var name: Output? = null

    private var network: Output? = null

    private var networkPolicy: Output? = null

    private var networkingMode: Output? = null

    private var nodeConfig: Output? = null

    private var nodeLocations: Output>? = null

    private var nodePoolAutoConfig: Output? = null

    private var nodePoolDefaults: Output? = null

    private var nodePools: Output>? = null

    private var nodeVersion: Output? = null

    private var notificationConfig: Output? = null

    private var podSecurityPolicyConfig: Output? = null

    private var privateClusterConfig: Output? = null

    private var privateIpv6GoogleAccess: Output? = null

    private var project: Output? = null

    private var protectConfig: Output? = null

    private var releaseChannel: Output? = null

    private var removeDefaultNodePool: Output? = null

    private var resourceLabels: Output>? = null

    private var resourceUsageExportConfig: Output? = null

    private var securityPostureConfig: Output? = null

    private var serviceExternalIpsConfig: Output? = null

    private var subnetwork: Output? = null

    private var tpuConfig: Output? = null

    private var verticalPodAutoscaling: Output? = null

    private var workloadAltsConfig: Output? = null

    private var workloadIdentityConfig: Output? = null

    /**
     * @param value The configuration for addons supported by GKE.
     * Structure is documented below.
     */
    @JvmName("asvmbyovaiyevvxk")
    public suspend fun addonsConfig(`value`: Output) {
        this.addonsConfig = value
    }

    /**
     * @param value Enable NET_ADMIN for the cluster. Defaults to
     * `false`. This field should only be enabled for Autopilot clusters (`enable_autopilot`
     * set to `true`).
     */
    @JvmName("wuryekjetjdqpklk")
    public suspend fun allowNetAdmin(`value`: Output) {
        this.allowNetAdmin = value
    }

    /**
     * @param value Configuration for the
     * [Google Groups for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/role-based-access-control#groups-setup-gsuite) feature.
     * Structure is documented below.
     */
    @JvmName("taoxndmblmmtmqif")
    public suspend fun authenticatorGroupsConfig(`value`: Output) {
        this.authenticatorGroupsConfig = value
    }

    /**
     * @param value Configuration options for the Binary
     * Authorization feature. Structure is documented below.
     */
    @JvmName("dsijflkvowactgvi")
    public suspend fun binaryAuthorization(`value`: Output) {
        this.binaryAuthorization = value
    }

    /**
     * @param value Per-cluster configuration of Node Auto-Provisioning with Cluster Autoscaler to
     * automatically adjust the size of the cluster and create/delete node pools based
     * on the current needs of the cluster's workload. See the
     * [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
     * for more details. Structure is documented below.
     */
    @JvmName("nkrqeulknpkfichp")
    public suspend fun clusterAutoscaling(`value`: Output) {
        this.clusterAutoscaling = value
    }

    /**
     * @param value The IP address range of the Kubernetes pods
     * in this cluster in CIDR notation (e.g. `10.96.0.0/14`). Leave blank to have one
     * automatically chosen or specify a `/14` block in `10.0.0.0/8`. This field will
     * default a new cluster to routes-based, where `ip_allocation_policy` is not defined.
     */
    @JvmName("hysddcymjxbpcgne")
    public suspend fun clusterIpv4Cidr(`value`: Output) {
        this.clusterIpv4Cidr = value
    }

    /**
     * @param value Configuration for
     * [ClusterTelemetry](https://cloud.google.com/monitoring/kubernetes-engine/installing#controlling_the_collection_of_application_logs) feature,
     * Structure is documented below.
     */
    @JvmName("ifjrwastalanyqpn")
    public suspend fun clusterTelemetry(`value`: Output) {
        this.clusterTelemetry = value
    }

    /**
     * @param value Configuration for [Confidential Nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/confidential-gke-nodes) feature. Structure is documented below documented below.
     */
    @JvmName("cuggnrusdcwprbtu")
    public suspend fun confidentialNodes(`value`: Output) {
        this.confidentialNodes = value
    }

    /**
     * @param value Configuration for the
     * [Cost Allocation](https://cloud.google.com/kubernetes-engine/docs/how-to/cost-allocations) feature.
     * Structure is documented below.
     */
    @JvmName("bmhsmdbqqrrebawt")
    public suspend fun costManagementConfig(`value`: Output) {
        this.costManagementConfig = value
    }

    /**
     * @param value Structure is documented below.
     */
    @JvmName("yjgyjhqfkwdhkjwv")
    public suspend fun databaseEncryption(`value`: Output) {
        this.databaseEncryption = value
    }

    /**
     * @param value The desired datapath provider for this cluster. This is set to `LEGACY_DATAPATH` by default, which uses the IPTables-based kube-proxy implementation. Set to `ADVANCED_DATAPATH` to enable Dataplane v2.
     */
    @JvmName("kmtamxdxsguvucna")
    public suspend fun datapathProvider(`value`: Output) {
        this.datapathProvider = value
    }

    /**
     * @param value The default maximum number of pods
     * per node in this cluster. This doesn't work on "routes-based" clusters, clusters
     * that don't have IP Aliasing enabled. See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/how-to/flexible-pod-cidr)
     * for more information.
     */
    @JvmName("vcwmbuwmgnrxfprd")
    public suspend fun defaultMaxPodsPerNode(`value`: Output) {
        this.defaultMaxPodsPerNode = value
    }

    /**
     * @param value [GKE SNAT](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-masquerade-agent#how_ipmasq_works) DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster, [API doc](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#networkconfig). Structure is documented below
     */
    @JvmName("hikjdskjrvosknkx")
    public suspend fun defaultSnatStatus(`value`: Output) {
        this.defaultSnatStatus = value
    }

    /**
     * @param value
     */
    @JvmName("caqoxvuxevfjabbg")
    public suspend fun deletionProtection(`value`: Output) {
        this.deletionProtection = value
    }

    /**
     * @param value Description of the cluster.
     */
    @JvmName("xhspuxxoesiyefls")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value Configuration for [Using Cloud DNS for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/cloud-dns). Structure is documented below.
     */
    @JvmName("ahwsrsewktppgukd")
    public suspend fun dnsConfig(`value`: Output) {
        this.dnsConfig = value
    }

    /**
     * @param value Enable Autopilot for this cluster. Defaults to `false`.
     * Note that when this option is enabled, certain features of Standard GKE are not available.
     * See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison)
     * for available features.
     */
    @JvmName("qncsbrqvyvtwnlpr")
    public suspend fun enableAutopilot(`value`: Output) {
        this.enableAutopilot = value
    }

    /**
     * @param value Whether CiliumClusterWideNetworkPolicy is enabled on this cluster. Defaults to false.
     */
    @JvmName("nkqrcgsfyybcukpf")
    public suspend fun enableCiliumClusterwideNetworkPolicy(`value`: Output) {
        this.enableCiliumClusterwideNetworkPolicy = value
    }

    /**
     * @param value Whether FQDN Network Policy is enabled on this cluster. Users who enable this feature for existing Standard clusters must restart the GKE Dataplane V2 `anetd` DaemonSet after enabling it. See the [Enable FQDN Network Policy in an existing cluster](https://cloud.google.com/kubernetes-engine/docs/how-to/fqdn-network-policies#enable_fqdn_network_policy_in_an_existing_cluster) for more information.
     */
    @JvmName("jiqmoqmkaygtiqxp")
    public suspend fun enableFqdnNetworkPolicy(`value`: Output) {
        this.enableFqdnNetworkPolicy = value
    }

    /**
     * @param value Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
     */
    @JvmName("wxnewgkwxekqcsis")
    public suspend fun enableIntranodeVisibility(`value`: Output) {
        this.enableIntranodeVisibility = value
    }

    /**
     * @param value Configuration for Kubernetes Beta APIs.
     * Structure is documented below.
     */
    @JvmName("ljuafurkxwusgbtq")
    public suspend fun enableK8sBetaApis(`value`: Output) {
        this.enableK8sBetaApis = value
    }

    /**
     * @param value Whether to enable Kubernetes Alpha features for
     * this cluster. Note that when this option is enabled, the cluster cannot be upgraded
     * and will be automatically deleted after 30 days.
     */
    @JvmName("lirxwifmcokqjrxk")
    public suspend fun enableKubernetesAlpha(`value`: Output) {
        this.enableKubernetesAlpha = value
    }

    /**
     * @param value Whether L4ILB Subsetting is enabled for this cluster.
     */
    @JvmName("ovhianfebjrjnbdi")
    public suspend fun enableL4IlbSubsetting(`value`: Output) {
        this.enableL4IlbSubsetting = value
    }

    /**
     * @param value Whether the ABAC authorizer is enabled for this cluster.
     * When enabled, identities in the system, including service accounts, nodes, and controllers,
     * will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
     * Defaults to `false`
     */
    @JvmName("fgpcyaylgwfclbck")
    public suspend fun enableLegacyAbac(`value`: Output) {
        this.enableLegacyAbac = value
    }

    /**
     * @param value Whether multi-networking is enabled for this cluster.
     */
    @JvmName("thtwpkopnnodiref")
    public suspend fun enableMultiNetworking(`value`: Output) {
        this.enableMultiNetworking = value
    }

    /**
     * @param value Enable Shielded Nodes features on all nodes in this cluster.  Defaults to `true`.
     */
    @JvmName("uwcrveilumkmwnkr")
    public suspend fun enableShieldedNodes(`value`: Output) {
        this.enableShieldedNodes = value
    }

    /**
     * @param value Whether to enable Cloud TPU resources in this cluster.
     * See the [official documentation](https://cloud.google.com/tpu/docs/kubernetes-engine-setup).
     */
    @JvmName("avxphdxkelkikmsq")
    public suspend fun enableTpu(`value`: Output) {
        this.enableTpu = value
    }

    /**
     * @param value Fleet configuration for the cluster. Structure is documented below.
     */
    @JvmName("ukjdubtmlpfqoero")
    public suspend fun fleet(`value`: Output) {
        this.fleet = value
    }

    /**
     * @param value Configuration for [GKE Gateway API controller](https://cloud.google.com/kubernetes-engine/docs/concepts/gateway-api). Structure is documented below.
     */
    @JvmName("egoxvgjafyedpdfy")
    public suspend fun gatewayApiConfig(`value`: Output) {
        this.gatewayApiConfig = value
    }

    /**
     * @param value . Structure is documented below.
     */
    @JvmName("mapwbgfugfhxrxnq")
    public suspend fun identityServiceConfig(`value`: Output) {
        this.identityServiceConfig = value
    }

    /**
     * @param value The number of nodes to create in this
     * cluster's default node pool. In regional or multi-zonal clusters, this is the
     * number of nodes per zone. Must be set if `node_pool` is not set. If you're using
     * `gcp.container.NodePool` objects with no default node pool, you'll need to
     * set this to a value of at least `1`, alongside setting
     * `remove_default_node_pool` to `true`.
     */
    @JvmName("ehktjmyhupnpmusx")
    public suspend fun initialNodeCount(`value`: Output) {
        this.initialNodeCount = value
    }

    /**
     * @param value Configuration of cluster IP allocation for
     * VPC-native clusters. If this block is unset during creation, it will be set by the GKE backend.
     * Structure is documented below.
     */
    @JvmName("giqhmpkriirqceua")
    public suspend fun ipAllocationPolicy(`value`: Output) {
        this.ipAllocationPolicy = value
    }

    /**
     * @param value The location (region or zone) in which the cluster
     * master will be created, as well as the default node location. If you specify a
     * zone (such as `us-central1-a`), the cluster will be a zonal cluster with a
     * single cluster master. If you specify a region (such as `us-west1`), the
     * cluster will be a regional cluster with multiple masters spread across zones in
     * the region, and with default node locations in those zones as well
     */
    @JvmName("snwxjmsuqrivhqud")
    public suspend fun location(`value`: Output) {
        this.location = value
    }

    /**
     * @param value Logging configuration for the cluster.
     * Structure is documented below.
     */
    @JvmName("hcjtpeguccwodanb")
    public suspend fun loggingConfig(`value`: Output) {
        this.loggingConfig = value
    }

    /**
     * @param value The logging service that the cluster should
     * write logs to. Available options include `logging.googleapis.com`(Legacy Stackdriver),
     * `logging.googleapis.com/kubernetes`(Stackdriver Kubernetes Engine Logging), and `none`. Defaults to `logging.googleapis.com/kubernetes`
     */
    @JvmName("wxcqvmeyqsltamqh")
    public suspend fun loggingService(`value`: Output) {
        this.loggingService = value
    }

    /**
     * @param value The maintenance policy to use for the cluster. Structure is
     * documented below.
     */
    @JvmName("jdyrbjvtusgjtrur")
    public suspend fun maintenancePolicy(`value`: Output) {
        this.maintenancePolicy = value
    }

    /**
     * @param value The authentication information for accessing the
     * Kubernetes master. Some values in this block are only returned by the API if
     * your service account has permission to get credentials for your GKE cluster. If
     * you see an unexpected diff unsetting your client cert, ensure you have the
     * `container.clusters.getCredentials` permission.
     * Structure is documented below.
     */
    @JvmName("jcysnbmgvuqlygcc")
    public suspend fun masterAuth(`value`: Output) {
        this.masterAuth = value
    }

    /**
     * @param value The desired
     * configuration options for master authorized networks. Omit the
     * nested `cidr_blocks` attribute to disallow external access (except
     * the cluster node IPs, which GKE automatically whitelists).
     * Structure is documented below.
     */
    @JvmName("jxflwlyooqbfukue")
    public suspend fun masterAuthorizedNetworksConfig(`value`: Output) {
        this.masterAuthorizedNetworksConfig = value
    }

    /**
     * @param value Structure is documented below.
     */
    @JvmName("dltrgvtqpwmwsqsf")
    public suspend fun meshCertificates(`value`: Output) {
        this.meshCertificates = value
    }

    /**
     * @param value The minimum version of the master. GKE
     * will auto-update the master to new versions, so this does not guarantee the
     * current master version--use the read-only `master_version` field to obtain that.
     * If unset, the cluster's version will be set by GKE to the version of the most recent
     * official release (which is not necessarily the latest version).  Most users will find
     * the `gcp.container.getEngineVersions` data source useful - it indicates which versions
     * are available. If you intend to specify versions manually,
     * [the docs](https://cloud.google.com/kubernetes-engine/versioning-and-upgrades#specifying_cluster_version)
     * describe the various acceptable formats for this field.
     * > If you are using the `gcp.container.getEngineVersions` datasource with a regional cluster, ensure that you have provided a `location`
     * to the datasource. A region can have a different set of supported versions than its corresponding zones, and not all zones in a
     * region are guaranteed to support the same version.
     */
    @JvmName("xgakgvduqegkxoco")
    public suspend fun minMasterVersion(`value`: Output) {
        this.minMasterVersion = value
    }

    /**
     * @param value Monitoring configuration for the cluster.
     * Structure is documented below.
     */
    @JvmName("dbmeietgavnogjfr")
    public suspend fun monitoringConfig(`value`: Output) {
        this.monitoringConfig = value
    }

    /**
     * @param value The monitoring service that the cluster
     * should write metrics to.
     * Automatically send metrics from pods in the cluster to the Google Cloud Monitoring API.
     * VM metrics will be collected by Google Compute Engine regardless of this setting
     * Available options include
     * `monitoring.googleapis.com`(Legacy Stackdriver), `monitoring.googleapis.com/kubernetes`(Stackdriver Kubernetes Engine Monitoring), and `none`.
     * Defaults to `monitoring.googleapis.com/kubernetes`
     */
    @JvmName("wkpojlkppxunostb")
    public suspend fun monitoringService(`value`: Output) {
        this.monitoringService = value
    }

    /**
     * @param value The name of the cluster, unique within the project and
     * location.
     * - - -
     */
    @JvmName("oddpatqyfpxmaevv")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value The name or self_link of the Google Compute Engine
     * network to which the cluster is connected. For Shared VPC, set this to the self link of the
     * shared network.
     */
    @JvmName("xwqnfxhriiovapsw")
    public suspend fun network(`value`: Output) {
        this.network = value
    }

    /**
     * @param value Configuration options for the
     * [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/networkpolicies/)
     * feature. Structure is documented below.
     */
    @JvmName("lkbdkclboeghjehv")
    public suspend fun networkPolicy(`value`: Output) {
        this.networkPolicy = value
    }

    /**
     * @param value Determines whether alias IPs or routes will be used for pod IPs in the cluster.
     * Options are `VPC_NATIVE` or `ROUTES`. `VPC_NATIVE` enables [IP aliasing](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-aliases). Newly created clusters will default to `VPC_NATIVE`.
     */
    @JvmName("sjbmruktjvckkwyw")
    public suspend fun networkingMode(`value`: Output) {
        this.networkingMode = value
    }

    /**
     * @param value Parameters used in creating the default node pool.
     * Generally, this field should not be used at the same time as a
     * `gcp.container.NodePool` or a `node_pool` block; this configuration
     * manages the default node pool, which isn't recommended to be used.
     * Structure is documented below.
     */
    @JvmName("cmisiemjqirvghug")
    public suspend fun nodeConfig(`value`: Output) {
        this.nodeConfig = value
    }

    /**
     * @param value The list of zones in which the cluster's nodes
     * are located. Nodes must be in the region of their regional cluster or in the
     * same region as their cluster's zone for zonal clusters. If this is specified for
     * a zonal cluster, omit the cluster's zone.
     * > A "multi-zonal" cluster is a zonal cluster with at least one additional zone
     * defined; in a multi-zonal cluster, the cluster master is only present in a
     * single zone while nodes are present in each of the primary zone and the node
     * locations. In contrast, in a regional cluster, cluster master nodes are present
     * in multiple zones in the region. For that reason, regional clusters should be
     * preferred.
     */
    @JvmName("swxslcgwycicpvcp")
    public suspend fun nodeLocations(`value`: Output>) {
        this.nodeLocations = value
    }

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

    /**
     * @param values The list of zones in which the cluster's nodes
     * are located. Nodes must be in the region of their regional cluster or in the
     * same region as their cluster's zone for zonal clusters. If this is specified for
     * a zonal cluster, omit the cluster's zone.
     * > A "multi-zonal" cluster is a zonal cluster with at least one additional zone
     * defined; in a multi-zonal cluster, the cluster master is only present in a
     * single zone while nodes are present in each of the primary zone and the node
     * locations. In contrast, in a regional cluster, cluster master nodes are present
     * in multiple zones in the region. For that reason, regional clusters should be
     * preferred.
     */
    @JvmName("vavvilfiyipwjllh")
    public suspend fun nodeLocations(values: List>) {
        this.nodeLocations = Output.all(values)
    }

    /**
     * @param value Node pool configs that apply to auto-provisioned node pools in
     * [autopilot](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison) clusters and
     * [node auto-provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)-enabled clusters. Structure is documented below.
     */
    @JvmName("wmhooghcbydrysvx")
    public suspend fun nodePoolAutoConfig(`value`: Output) {
        this.nodePoolAutoConfig = value
    }

    /**
     * @param value Default NodePool settings for the entire cluster. These settings are overridden if specified on the specific NodePool object. Structure is documented below.
     */
    @JvmName("ldqehrhvkgkwohtl")
    public suspend fun nodePoolDefaults(`value`: Output) {
        this.nodePoolDefaults = value
    }

    /**
     * @param value List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("eymalewfthcyoxhv")
    public suspend fun nodePools(`value`: Output>) {
        this.nodePools = value
    }

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

    /**
     * @param values List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("hvqeoeypldgtpbec")
    public suspend fun nodePools(values: List>) {
        this.nodePools = Output.all(values)
    }

    /**
     * @param value The Kubernetes version on the nodes. Must either be unset
     * or set to the same value as `min_master_version` on create. Defaults to the default
     * version set by GKE which is not necessarily the latest version. This only affects
     * nodes in the default node pool. While a fuzzy version can be specified, it's
     * recommended that you specify explicit versions as the provider will see spurious diffs
     * when fuzzy versions are used. See the `gcp.container.getEngineVersions` data source's
     * `version_prefix` field to approximate fuzzy versions.
     * To update nodes in other node pools, use the `version` attribute on the node pool.
     */
    @JvmName("ftfigxbvclxruqhr")
    public suspend fun nodeVersion(`value`: Output) {
        this.nodeVersion = value
    }

    /**
     * @param value Configuration for the [cluster upgrade notifications](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-upgrade-notifications) feature. Structure is documented below.
     */
    @JvmName("iroelghwrwbimimq")
    public suspend fun notificationConfig(`value`: Output) {
        this.notificationConfig = value
    }

    /**
     * @param value Configuration for the
     * [PodSecurityPolicy](https://cloud.google.com/kubernetes-engine/docs/how-to/pod-security-policies) feature.
     * Structure is documented below.
     */
    @JvmName("hoasjwlahncohbxc")
    public suspend fun podSecurityPolicyConfig(`value`: Output) {
        this.podSecurityPolicyConfig = value
    }

    /**
     * @param value Configuration for [private clusters](https://cloud.google.com/kubernetes-engine/docs/how-to/private-clusters),
     * clusters with private nodes. Structure is documented below.
     */
    @JvmName("yqrkdtxaocepymbi")
    public suspend fun privateClusterConfig(`value`: Output) {
        this.privateClusterConfig = value
    }

    /**
     * @param value The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4).
     */
    @JvmName("gdqeqrullqxdumad")
    public suspend fun privateIpv6GoogleAccess(`value`: Output) {
        this.privateIpv6GoogleAccess = value
    }

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

    /**
     * @param value Enable/Disable Protect API features for the cluster. Structure is documented below.
     */
    @JvmName("pgnptqntjxeudxdn")
    public suspend fun protectConfig(`value`: Output) {
        this.protectConfig = value
    }

    /**
     * @param value Configuration options for the [Release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels)
     * feature, which provide more control over automatic upgrades of your GKE clusters.
     * When updating this field, GKE imposes specific version requirements. See
     * [Selecting a new release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels#selecting_a_new_release_channel)
     * for more details; the `gcp.container.getEngineVersions` datasource can provide
     * the default version for a channel. Note that removing the `release_channel`
     * field from your config will cause the provider to stop managing your cluster's
     * release channel, but will not unenroll it. Instead, use the `"UNSPECIFIED"`
     * channel. Structure is documented below.
     */
    @JvmName("judjkqyxvoakltip")
    public suspend fun releaseChannel(`value`: Output) {
        this.releaseChannel = value
    }

    /**
     * @param value If `true`, deletes the default node
     * pool upon cluster creation. If you're using `gcp.container.NodePool`
     * resources with no default node pool, this should be set to `true`, alongside
     * setting `initial_node_count` to at least `1`.
     */
    @JvmName("wtxshojlwnuoypxy")
    public suspend fun removeDefaultNodePool(`value`: Output) {
        this.removeDefaultNodePool = value
    }

    /**
     * @param value The GCE resource labels (a map of key/value pairs) to be applied to the cluster.
     */
    @JvmName("bbfkfforvjgsoukb")
    public suspend fun resourceLabels(`value`: Output>) {
        this.resourceLabels = value
    }

    /**
     * @param value Configuration for the
     * [ResourceUsageExportConfig](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-usage-metering) feature.
     * Structure is documented below.
     */
    @JvmName("bnkdevqmkpkqpsdb")
    public suspend fun resourceUsageExportConfig(`value`: Output) {
        this.resourceUsageExportConfig = value
    }

    /**
     * @param value Enable/Disable Security Posture API features for the cluster. Structure is documented below.
     */
    @JvmName("cjbnawribbwokmtp")
    public suspend fun securityPostureConfig(`value`: Output) {
        this.securityPostureConfig = value
    }

    /**
     * @param value Structure is documented below.
     */
    @JvmName("nimqqgvtncnbwmil")
    public suspend fun serviceExternalIpsConfig(`value`: Output) {
        this.serviceExternalIpsConfig = value
    }

    /**
     * @param value The name or self_link of the Google Compute Engine
     * subnetwork in which the cluster's instances are launched.
     */
    @JvmName("tcdedjpkrmkydlmd")
    public suspend fun subnetwork(`value`: Output) {
        this.subnetwork = value
    }

    /**
     * @param value TPU configuration for the cluster.
     */
    @JvmName("gbqbxlkvqxcocjrb")
    public suspend fun tpuConfig(`value`: Output) {
        this.tpuConfig = value
    }

    /**
     * @param value Vertical Pod Autoscaling automatically adjusts the resources of pods controlled by it.
     * Structure is documented below.
     */
    @JvmName("ehrjhjdsegmgweto")
    public suspend fun verticalPodAutoscaling(`value`: Output) {
        this.verticalPodAutoscaling = value
    }

    /**
     * @param value Configuration for [direct-path (via ALTS) with workload identity.](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#workloadaltsconfig). Structure is documented below.
     * The `default_snat_status` block supports
     */
    @JvmName("ntgqvqjotjaabjut")
    public suspend fun workloadAltsConfig(`value`: Output) {
        this.workloadAltsConfig = value
    }

    /**
     * @param value Workload Identity allows Kubernetes service accounts to act as a user-managed
     * [Google IAM Service Account](https://cloud.google.com/iam/docs/service-accounts#user-managed_service_accounts).
     * Structure is documented below.
     */
    @JvmName("lhwpxtkndvjukybb")
    public suspend fun workloadIdentityConfig(`value`: Output) {
        this.workloadIdentityConfig = value
    }

    /**
     * @param value The configuration for addons supported by GKE.
     * Structure is documented below.
     */
    @JvmName("fdcfbkpugmyjnvbx")
    public suspend fun addonsConfig(`value`: ClusterAddonsConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.addonsConfig = mapped
    }

    /**
     * @param argument The configuration for addons supported by GKE.
     * Structure is documented below.
     */
    @JvmName("klrqreyepghktpxi")
    public suspend fun addonsConfig(argument: suspend ClusterAddonsConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterAddonsConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.addonsConfig = mapped
    }

    /**
     * @param value Enable NET_ADMIN for the cluster. Defaults to
     * `false`. This field should only be enabled for Autopilot clusters (`enable_autopilot`
     * set to `true`).
     */
    @JvmName("qcrdcqetrauyccod")
    public suspend fun allowNetAdmin(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.allowNetAdmin = mapped
    }

    /**
     * @param value Configuration for the
     * [Google Groups for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/role-based-access-control#groups-setup-gsuite) feature.
     * Structure is documented below.
     */
    @JvmName("tuodrpofvepxbule")
    public suspend fun authenticatorGroupsConfig(`value`: ClusterAuthenticatorGroupsConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.authenticatorGroupsConfig = mapped
    }

    /**
     * @param argument Configuration for the
     * [Google Groups for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/role-based-access-control#groups-setup-gsuite) feature.
     * Structure is documented below.
     */
    @JvmName("tklwmubmawguvsvo")
    public suspend fun authenticatorGroupsConfig(argument: suspend ClusterAuthenticatorGroupsConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterAuthenticatorGroupsConfigArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.authenticatorGroupsConfig = mapped
    }

    /**
     * @param value Configuration options for the Binary
     * Authorization feature. Structure is documented below.
     */
    @JvmName("fkddqeqdgylrsual")
    public suspend fun binaryAuthorization(`value`: ClusterBinaryAuthorizationArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.binaryAuthorization = mapped
    }

    /**
     * @param argument Configuration options for the Binary
     * Authorization feature. Structure is documented below.
     */
    @JvmName("wajknogynsytjulb")
    public suspend fun binaryAuthorization(argument: suspend ClusterBinaryAuthorizationArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterBinaryAuthorizationArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.binaryAuthorization = mapped
    }

    /**
     * @param value Per-cluster configuration of Node Auto-Provisioning with Cluster Autoscaler to
     * automatically adjust the size of the cluster and create/delete node pools based
     * on the current needs of the cluster's workload. See the
     * [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
     * for more details. Structure is documented below.
     */
    @JvmName("iebxtnkxoobtpmek")
    public suspend fun clusterAutoscaling(`value`: ClusterClusterAutoscalingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.clusterAutoscaling = mapped
    }

    /**
     * @param argument Per-cluster configuration of Node Auto-Provisioning with Cluster Autoscaler to
     * automatically adjust the size of the cluster and create/delete node pools based
     * on the current needs of the cluster's workload. See the
     * [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
     * for more details. Structure is documented below.
     */
    @JvmName("mllsbeqphqujgxhl")
    public suspend fun clusterAutoscaling(argument: suspend ClusterClusterAutoscalingArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterClusterAutoscalingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.clusterAutoscaling = mapped
    }

    /**
     * @param value The IP address range of the Kubernetes pods
     * in this cluster in CIDR notation (e.g. `10.96.0.0/14`). Leave blank to have one
     * automatically chosen or specify a `/14` block in `10.0.0.0/8`. This field will
     * default a new cluster to routes-based, where `ip_allocation_policy` is not defined.
     */
    @JvmName("yupmfurflvyyviay")
    public suspend fun clusterIpv4Cidr(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.clusterIpv4Cidr = mapped
    }

    /**
     * @param value Configuration for
     * [ClusterTelemetry](https://cloud.google.com/monitoring/kubernetes-engine/installing#controlling_the_collection_of_application_logs) feature,
     * Structure is documented below.
     */
    @JvmName("frkpjnehvnwndbwh")
    public suspend fun clusterTelemetry(`value`: ClusterClusterTelemetryArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.clusterTelemetry = mapped
    }

    /**
     * @param argument Configuration for
     * [ClusterTelemetry](https://cloud.google.com/monitoring/kubernetes-engine/installing#controlling_the_collection_of_application_logs) feature,
     * Structure is documented below.
     */
    @JvmName("appkecdeivgmmcap")
    public suspend fun clusterTelemetry(argument: suspend ClusterClusterTelemetryArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterClusterTelemetryArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.clusterTelemetry = mapped
    }

    /**
     * @param value Configuration for [Confidential Nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/confidential-gke-nodes) feature. Structure is documented below documented below.
     */
    @JvmName("mdtfhyepdoikmsgc")
    public suspend fun confidentialNodes(`value`: ClusterConfidentialNodesArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.confidentialNodes = mapped
    }

    /**
     * @param argument Configuration for [Confidential Nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/confidential-gke-nodes) feature. Structure is documented below documented below.
     */
    @JvmName("pisysoiwevejisxh")
    public suspend fun confidentialNodes(argument: suspend ClusterConfidentialNodesArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterConfidentialNodesArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.confidentialNodes = mapped
    }

    /**
     * @param value Configuration for the
     * [Cost Allocation](https://cloud.google.com/kubernetes-engine/docs/how-to/cost-allocations) feature.
     * Structure is documented below.
     */
    @JvmName("rioveepvcfdexohr")
    public suspend fun costManagementConfig(`value`: ClusterCostManagementConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.costManagementConfig = mapped
    }

    /**
     * @param argument Configuration for the
     * [Cost Allocation](https://cloud.google.com/kubernetes-engine/docs/how-to/cost-allocations) feature.
     * Structure is documented below.
     */
    @JvmName("usogescgbquenxgs")
    public suspend fun costManagementConfig(argument: suspend ClusterCostManagementConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterCostManagementConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.costManagementConfig = mapped
    }

    /**
     * @param value Structure is documented below.
     */
    @JvmName("kongxiekeknejvmi")
    public suspend fun databaseEncryption(`value`: ClusterDatabaseEncryptionArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.databaseEncryption = mapped
    }

    /**
     * @param argument Structure is documented below.
     */
    @JvmName("skbwpfodwedtxpnt")
    public suspend fun databaseEncryption(argument: suspend ClusterDatabaseEncryptionArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterDatabaseEncryptionArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.databaseEncryption = mapped
    }

    /**
     * @param value The desired datapath provider for this cluster. This is set to `LEGACY_DATAPATH` by default, which uses the IPTables-based kube-proxy implementation. Set to `ADVANCED_DATAPATH` to enable Dataplane v2.
     */
    @JvmName("nppfdcngsrnuwdws")
    public suspend fun datapathProvider(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.datapathProvider = mapped
    }

    /**
     * @param value The default maximum number of pods
     * per node in this cluster. This doesn't work on "routes-based" clusters, clusters
     * that don't have IP Aliasing enabled. See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/how-to/flexible-pod-cidr)
     * for more information.
     */
    @JvmName("hsscoxwbquqccwlc")
    public suspend fun defaultMaxPodsPerNode(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.defaultMaxPodsPerNode = mapped
    }

    /**
     * @param value [GKE SNAT](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-masquerade-agent#how_ipmasq_works) DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster, [API doc](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#networkconfig). Structure is documented below
     */
    @JvmName("mwajglqupjkgdica")
    public suspend fun defaultSnatStatus(`value`: ClusterDefaultSnatStatusArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.defaultSnatStatus = mapped
    }

    /**
     * @param argument [GKE SNAT](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-masquerade-agent#how_ipmasq_works) DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster, [API doc](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#networkconfig). Structure is documented below
     */
    @JvmName("ymwaudlqfpnpqrca")
    public suspend fun defaultSnatStatus(argument: suspend ClusterDefaultSnatStatusArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterDefaultSnatStatusArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.defaultSnatStatus = mapped
    }

    /**
     * @param value
     */
    @JvmName("tuimvofpiemdqfra")
    public suspend fun deletionProtection(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.deletionProtection = mapped
    }

    /**
     * @param value Description of the cluster.
     */
    @JvmName("aeycybbbputwhwtk")
    public suspend fun description(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.description = mapped
    }

    /**
     * @param value Configuration for [Using Cloud DNS for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/cloud-dns). Structure is documented below.
     */
    @JvmName("wplvxyikxfbfopwh")
    public suspend fun dnsConfig(`value`: ClusterDnsConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dnsConfig = mapped
    }

    /**
     * @param argument Configuration for [Using Cloud DNS for GKE](https://cloud.google.com/kubernetes-engine/docs/how-to/cloud-dns). Structure is documented below.
     */
    @JvmName("rokuctbgmcmsovct")
    public suspend fun dnsConfig(argument: suspend ClusterDnsConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterDnsConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.dnsConfig = mapped
    }

    /**
     * @param value Enable Autopilot for this cluster. Defaults to `false`.
     * Note that when this option is enabled, certain features of Standard GKE are not available.
     * See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison)
     * for available features.
     */
    @JvmName("njucehembjobcigy")
    public suspend fun enableAutopilot(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableAutopilot = mapped
    }

    /**
     * @param value Whether CiliumClusterWideNetworkPolicy is enabled on this cluster. Defaults to false.
     */
    @JvmName("lerpwktumeqrvhjs")
    public suspend fun enableCiliumClusterwideNetworkPolicy(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableCiliumClusterwideNetworkPolicy = mapped
    }

    /**
     * @param value Whether FQDN Network Policy is enabled on this cluster. Users who enable this feature for existing Standard clusters must restart the GKE Dataplane V2 `anetd` DaemonSet after enabling it. See the [Enable FQDN Network Policy in an existing cluster](https://cloud.google.com/kubernetes-engine/docs/how-to/fqdn-network-policies#enable_fqdn_network_policy_in_an_existing_cluster) for more information.
     */
    @JvmName("aqgrnvoselohmifj")
    public suspend fun enableFqdnNetworkPolicy(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableFqdnNetworkPolicy = mapped
    }

    /**
     * @param value Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
     */
    @JvmName("diexcppwtbpinivr")
    public suspend fun enableIntranodeVisibility(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableIntranodeVisibility = mapped
    }

    /**
     * @param value Configuration for Kubernetes Beta APIs.
     * Structure is documented below.
     */
    @JvmName("jwemcptjmlsvxqqe")
    public suspend fun enableK8sBetaApis(`value`: ClusterEnableK8sBetaApisArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableK8sBetaApis = mapped
    }

    /**
     * @param argument Configuration for Kubernetes Beta APIs.
     * Structure is documented below.
     */
    @JvmName("jsimuwekmnbscsok")
    public suspend fun enableK8sBetaApis(argument: suspend ClusterEnableK8sBetaApisArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterEnableK8sBetaApisArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.enableK8sBetaApis = mapped
    }

    /**
     * @param value Whether to enable Kubernetes Alpha features for
     * this cluster. Note that when this option is enabled, the cluster cannot be upgraded
     * and will be automatically deleted after 30 days.
     */
    @JvmName("tvrkssupeloybpcm")
    public suspend fun enableKubernetesAlpha(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableKubernetesAlpha = mapped
    }

    /**
     * @param value Whether L4ILB Subsetting is enabled for this cluster.
     */
    @JvmName("ccadhbfbffaosxvx")
    public suspend fun enableL4IlbSubsetting(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableL4IlbSubsetting = mapped
    }

    /**
     * @param value Whether the ABAC authorizer is enabled for this cluster.
     * When enabled, identities in the system, including service accounts, nodes, and controllers,
     * will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
     * Defaults to `false`
     */
    @JvmName("rlvxtmwdxrdjepqv")
    public suspend fun enableLegacyAbac(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableLegacyAbac = mapped
    }

    /**
     * @param value Whether multi-networking is enabled for this cluster.
     */
    @JvmName("xaubptyriwthqdmc")
    public suspend fun enableMultiNetworking(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableMultiNetworking = mapped
    }

    /**
     * @param value Enable Shielded Nodes features on all nodes in this cluster.  Defaults to `true`.
     */
    @JvmName("xhhtssevbcaugqmg")
    public suspend fun enableShieldedNodes(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableShieldedNodes = mapped
    }

    /**
     * @param value Whether to enable Cloud TPU resources in this cluster.
     * See the [official documentation](https://cloud.google.com/tpu/docs/kubernetes-engine-setup).
     */
    @JvmName("wrmelakyndfdpdlv")
    public suspend fun enableTpu(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableTpu = mapped
    }

    /**
     * @param value Fleet configuration for the cluster. Structure is documented below.
     */
    @JvmName("ofunrovguxagwvbb")
    public suspend fun fleet(`value`: ClusterFleetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.fleet = mapped
    }

    /**
     * @param argument Fleet configuration for the cluster. Structure is documented below.
     */
    @JvmName("uhhsuojrsaeefxqi")
    public suspend fun fleet(argument: suspend ClusterFleetArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterFleetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.fleet = mapped
    }

    /**
     * @param value Configuration for [GKE Gateway API controller](https://cloud.google.com/kubernetes-engine/docs/concepts/gateway-api). Structure is documented below.
     */
    @JvmName("mglisoqtlwidgjsv")
    public suspend fun gatewayApiConfig(`value`: ClusterGatewayApiConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.gatewayApiConfig = mapped
    }

    /**
     * @param argument Configuration for [GKE Gateway API controller](https://cloud.google.com/kubernetes-engine/docs/concepts/gateway-api). Structure is documented below.
     */
    @JvmName("ovrnusyufisirlgn")
    public suspend fun gatewayApiConfig(argument: suspend ClusterGatewayApiConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterGatewayApiConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.gatewayApiConfig = mapped
    }

    /**
     * @param value . Structure is documented below.
     */
    @JvmName("wmhjwsrxqhrphypb")
    public suspend fun identityServiceConfig(`value`: ClusterIdentityServiceConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.identityServiceConfig = mapped
    }

    /**
     * @param argument . Structure is documented below.
     */
    @JvmName("ouaqinmcytmnqyrf")
    public suspend fun identityServiceConfig(argument: suspend ClusterIdentityServiceConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterIdentityServiceConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.identityServiceConfig = mapped
    }

    /**
     * @param value The number of nodes to create in this
     * cluster's default node pool. In regional or multi-zonal clusters, this is the
     * number of nodes per zone. Must be set if `node_pool` is not set. If you're using
     * `gcp.container.NodePool` objects with no default node pool, you'll need to
     * set this to a value of at least `1`, alongside setting
     * `remove_default_node_pool` to `true`.
     */
    @JvmName("wodnopcbbnskkhig")
    public suspend fun initialNodeCount(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.initialNodeCount = mapped
    }

    /**
     * @param value Configuration of cluster IP allocation for
     * VPC-native clusters. If this block is unset during creation, it will be set by the GKE backend.
     * Structure is documented below.
     */
    @JvmName("pkfkiwnqktamyciw")
    public suspend fun ipAllocationPolicy(`value`: ClusterIpAllocationPolicyArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.ipAllocationPolicy = mapped
    }

    /**
     * @param argument Configuration of cluster IP allocation for
     * VPC-native clusters. If this block is unset during creation, it will be set by the GKE backend.
     * Structure is documented below.
     */
    @JvmName("pxatppsumwxlmasr")
    public suspend fun ipAllocationPolicy(argument: suspend ClusterIpAllocationPolicyArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterIpAllocationPolicyArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.ipAllocationPolicy = mapped
    }

    /**
     * @param value The location (region or zone) in which the cluster
     * master will be created, as well as the default node location. If you specify a
     * zone (such as `us-central1-a`), the cluster will be a zonal cluster with a
     * single cluster master. If you specify a region (such as `us-west1`), the
     * cluster will be a regional cluster with multiple masters spread across zones in
     * the region, and with default node locations in those zones as well
     */
    @JvmName("mqtxmrrbldtqponk")
    public suspend fun location(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.location = mapped
    }

    /**
     * @param value Logging configuration for the cluster.
     * Structure is documented below.
     */
    @JvmName("tnnyvuoxpkjprnva")
    public suspend fun loggingConfig(`value`: ClusterLoggingConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.loggingConfig = mapped
    }

    /**
     * @param argument Logging configuration for the cluster.
     * Structure is documented below.
     */
    @JvmName("jduxunptjkcohdlh")
    public suspend fun loggingConfig(argument: suspend ClusterLoggingConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterLoggingConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.loggingConfig = mapped
    }

    /**
     * @param value The logging service that the cluster should
     * write logs to. Available options include `logging.googleapis.com`(Legacy Stackdriver),
     * `logging.googleapis.com/kubernetes`(Stackdriver Kubernetes Engine Logging), and `none`. Defaults to `logging.googleapis.com/kubernetes`
     */
    @JvmName("yfqaxkrdkjstggce")
    public suspend fun loggingService(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.loggingService = mapped
    }

    /**
     * @param value The maintenance policy to use for the cluster. Structure is
     * documented below.
     */
    @JvmName("uoxnlgktsogtanng")
    public suspend fun maintenancePolicy(`value`: ClusterMaintenancePolicyArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maintenancePolicy = mapped
    }

    /**
     * @param argument The maintenance policy to use for the cluster. Structure is
     * documented below.
     */
    @JvmName("oahhutpwqasdkhdp")
    public suspend fun maintenancePolicy(argument: suspend ClusterMaintenancePolicyArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterMaintenancePolicyArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.maintenancePolicy = mapped
    }

    /**
     * @param value The authentication information for accessing the
     * Kubernetes master. Some values in this block are only returned by the API if
     * your service account has permission to get credentials for your GKE cluster. If
     * you see an unexpected diff unsetting your client cert, ensure you have the
     * `container.clusters.getCredentials` permission.
     * Structure is documented below.
     */
    @JvmName("rxtbjvgfjoeqcmaq")
    public suspend fun masterAuth(`value`: ClusterMasterAuthArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.masterAuth = mapped
    }

    /**
     * @param argument The authentication information for accessing the
     * Kubernetes master. Some values in this block are only returned by the API if
     * your service account has permission to get credentials for your GKE cluster. If
     * you see an unexpected diff unsetting your client cert, ensure you have the
     * `container.clusters.getCredentials` permission.
     * Structure is documented below.
     */
    @JvmName("qfxkcvtapilbuenb")
    public suspend fun masterAuth(argument: suspend ClusterMasterAuthArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterMasterAuthArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.masterAuth = mapped
    }

    /**
     * @param value The desired
     * configuration options for master authorized networks. Omit the
     * nested `cidr_blocks` attribute to disallow external access (except
     * the cluster node IPs, which GKE automatically whitelists).
     * Structure is documented below.
     */
    @JvmName("wdjgvpixelwukpha")
    public suspend fun masterAuthorizedNetworksConfig(`value`: ClusterMasterAuthorizedNetworksConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.masterAuthorizedNetworksConfig = mapped
    }

    /**
     * @param argument The desired
     * configuration options for master authorized networks. Omit the
     * nested `cidr_blocks` attribute to disallow external access (except
     * the cluster node IPs, which GKE automatically whitelists).
     * Structure is documented below.
     */
    @JvmName("vipsjelcibdcbvuu")
    public suspend fun masterAuthorizedNetworksConfig(argument: suspend ClusterMasterAuthorizedNetworksConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterMasterAuthorizedNetworksConfigArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.masterAuthorizedNetworksConfig = mapped
    }

    /**
     * @param value Structure is documented below.
     */
    @JvmName("jselbudfsysumdic")
    public suspend fun meshCertificates(`value`: ClusterMeshCertificatesArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.meshCertificates = mapped
    }

    /**
     * @param argument Structure is documented below.
     */
    @JvmName("smluqccjmneiejfn")
    public suspend fun meshCertificates(argument: suspend ClusterMeshCertificatesArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterMeshCertificatesArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.meshCertificates = mapped
    }

    /**
     * @param value The minimum version of the master. GKE
     * will auto-update the master to new versions, so this does not guarantee the
     * current master version--use the read-only `master_version` field to obtain that.
     * If unset, the cluster's version will be set by GKE to the version of the most recent
     * official release (which is not necessarily the latest version).  Most users will find
     * the `gcp.container.getEngineVersions` data source useful - it indicates which versions
     * are available. If you intend to specify versions manually,
     * [the docs](https://cloud.google.com/kubernetes-engine/versioning-and-upgrades#specifying_cluster_version)
     * describe the various acceptable formats for this field.
     * > If you are using the `gcp.container.getEngineVersions` datasource with a regional cluster, ensure that you have provided a `location`
     * to the datasource. A region can have a different set of supported versions than its corresponding zones, and not all zones in a
     * region are guaranteed to support the same version.
     */
    @JvmName("gasiccyoxxoeidfw")
    public suspend fun minMasterVersion(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.minMasterVersion = mapped
    }

    /**
     * @param value Monitoring configuration for the cluster.
     * Structure is documented below.
     */
    @JvmName("krtysvgjytidrvmn")
    public suspend fun monitoringConfig(`value`: ClusterMonitoringConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.monitoringConfig = mapped
    }

    /**
     * @param argument Monitoring configuration for the cluster.
     * Structure is documented below.
     */
    @JvmName("awpxixvogjpqrlyn")
    public suspend fun monitoringConfig(argument: suspend ClusterMonitoringConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterMonitoringConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.monitoringConfig = mapped
    }

    /**
     * @param value The monitoring service that the cluster
     * should write metrics to.
     * Automatically send metrics from pods in the cluster to the Google Cloud Monitoring API.
     * VM metrics will be collected by Google Compute Engine regardless of this setting
     * Available options include
     * `monitoring.googleapis.com`(Legacy Stackdriver), `monitoring.googleapis.com/kubernetes`(Stackdriver Kubernetes Engine Monitoring), and `none`.
     * Defaults to `monitoring.googleapis.com/kubernetes`
     */
    @JvmName("vadyjlwyobswtwdb")
    public suspend fun monitoringService(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.monitoringService = mapped
    }

    /**
     * @param value The name of the cluster, unique within the project and
     * location.
     * - - -
     */
    @JvmName("edggqfmjoewpilih")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value The name or self_link of the Google Compute Engine
     * network to which the cluster is connected. For Shared VPC, set this to the self link of the
     * shared network.
     */
    @JvmName("xhvlhtngvxnwjehj")
    public suspend fun network(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.network = mapped
    }

    /**
     * @param value Configuration options for the
     * [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/networkpolicies/)
     * feature. Structure is documented below.
     */
    @JvmName("qhobqowjiwnbexux")
    public suspend fun networkPolicy(`value`: ClusterNetworkPolicyArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.networkPolicy = mapped
    }

    /**
     * @param argument Configuration options for the
     * [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/networkpolicies/)
     * feature. Structure is documented below.
     */
    @JvmName("njqsvunurditicst")
    public suspend fun networkPolicy(argument: suspend ClusterNetworkPolicyArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterNetworkPolicyArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.networkPolicy = mapped
    }

    /**
     * @param value Determines whether alias IPs or routes will be used for pod IPs in the cluster.
     * Options are `VPC_NATIVE` or `ROUTES`. `VPC_NATIVE` enables [IP aliasing](https://cloud.google.com/kubernetes-engine/docs/how-to/ip-aliases). Newly created clusters will default to `VPC_NATIVE`.
     */
    @JvmName("tdxwlemwoblecwsk")
    public suspend fun networkingMode(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.networkingMode = mapped
    }

    /**
     * @param value Parameters used in creating the default node pool.
     * Generally, this field should not be used at the same time as a
     * `gcp.container.NodePool` or a `node_pool` block; this configuration
     * manages the default node pool, which isn't recommended to be used.
     * Structure is documented below.
     */
    @JvmName("kgndgfanlhuepvyk")
    public suspend fun nodeConfig(`value`: ClusterNodeConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nodeConfig = mapped
    }

    /**
     * @param argument Parameters used in creating the default node pool.
     * Generally, this field should not be used at the same time as a
     * `gcp.container.NodePool` or a `node_pool` block; this configuration
     * manages the default node pool, which isn't recommended to be used.
     * Structure is documented below.
     */
    @JvmName("gfnadctvpqfpfvqd")
    public suspend fun nodeConfig(argument: suspend ClusterNodeConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterNodeConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.nodeConfig = mapped
    }

    /**
     * @param value The list of zones in which the cluster's nodes
     * are located. Nodes must be in the region of their regional cluster or in the
     * same region as their cluster's zone for zonal clusters. If this is specified for
     * a zonal cluster, omit the cluster's zone.
     * > A "multi-zonal" cluster is a zonal cluster with at least one additional zone
     * defined; in a multi-zonal cluster, the cluster master is only present in a
     * single zone while nodes are present in each of the primary zone and the node
     * locations. In contrast, in a regional cluster, cluster master nodes are present
     * in multiple zones in the region. For that reason, regional clusters should be
     * preferred.
     */
    @JvmName("quwsfvebmhdubisp")
    public suspend fun nodeLocations(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nodeLocations = mapped
    }

    /**
     * @param values The list of zones in which the cluster's nodes
     * are located. Nodes must be in the region of their regional cluster or in the
     * same region as their cluster's zone for zonal clusters. If this is specified for
     * a zonal cluster, omit the cluster's zone.
     * > A "multi-zonal" cluster is a zonal cluster with at least one additional zone
     * defined; in a multi-zonal cluster, the cluster master is only present in a
     * single zone while nodes are present in each of the primary zone and the node
     * locations. In contrast, in a regional cluster, cluster master nodes are present
     * in multiple zones in the region. For that reason, regional clusters should be
     * preferred.
     */
    @JvmName("onmvduoxgkmgviro")
    public suspend fun nodeLocations(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.nodeLocations = mapped
    }

    /**
     * @param value Node pool configs that apply to auto-provisioned node pools in
     * [autopilot](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison) clusters and
     * [node auto-provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)-enabled clusters. Structure is documented below.
     */
    @JvmName("xwylcpseklwgrlgj")
    public suspend fun nodePoolAutoConfig(`value`: ClusterNodePoolAutoConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nodePoolAutoConfig = mapped
    }

    /**
     * @param argument Node pool configs that apply to auto-provisioned node pools in
     * [autopilot](https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-overview#comparison) clusters and
     * [node auto-provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)-enabled clusters. Structure is documented below.
     */
    @JvmName("tdigvoeakrsvacex")
    public suspend fun nodePoolAutoConfig(argument: suspend ClusterNodePoolAutoConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterNodePoolAutoConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.nodePoolAutoConfig = mapped
    }

    /**
     * @param value Default NodePool settings for the entire cluster. These settings are overridden if specified on the specific NodePool object. Structure is documented below.
     */
    @JvmName("ytpyfkvftstayppa")
    public suspend fun nodePoolDefaults(`value`: ClusterNodePoolDefaultsArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nodePoolDefaults = mapped
    }

    /**
     * @param argument Default NodePool settings for the entire cluster. These settings are overridden if specified on the specific NodePool object. Structure is documented below.
     */
    @JvmName("xvvrvgpfokmdhjkw")
    public suspend fun nodePoolDefaults(argument: suspend ClusterNodePoolDefaultsArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterNodePoolDefaultsArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.nodePoolDefaults = mapped
    }

    /**
     * @param value List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("oxfcqratnfvqqxqv")
    public suspend fun nodePools(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nodePools = mapped
    }

    /**
     * @param argument List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("jsucpjrpggejnbyj")
    public suspend fun nodePools(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            ClusterNodePoolArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.nodePools = mapped
    }

    /**
     * @param argument List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("cuxorshhfvuguojb")
    public suspend fun nodePools(vararg argument: suspend ClusterNodePoolArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            ClusterNodePoolArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.nodePools = mapped
    }

    /**
     * @param argument List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("reiyxmbqyerobbrh")
    public suspend fun nodePools(argument: suspend ClusterNodePoolArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(ClusterNodePoolArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.nodePools = mapped
    }

    /**
     * @param values List of node pools associated with this cluster.
     * See gcp.container.NodePool for schema.
     * **Warning:** node pools defined inside a cluster can't be changed (or added/removed) after
     * cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability
     * to say "these are the _only_ node pools associated with this cluster", use the
     * gcp.container.NodePool resource instead of this property.
     */
    @JvmName("stxklawukirrskuh")
    public suspend fun nodePools(vararg values: ClusterNodePoolArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.nodePools = mapped
    }

    /**
     * @param value The Kubernetes version on the nodes. Must either be unset
     * or set to the same value as `min_master_version` on create. Defaults to the default
     * version set by GKE which is not necessarily the latest version. This only affects
     * nodes in the default node pool. While a fuzzy version can be specified, it's
     * recommended that you specify explicit versions as the provider will see spurious diffs
     * when fuzzy versions are used. See the `gcp.container.getEngineVersions` data source's
     * `version_prefix` field to approximate fuzzy versions.
     * To update nodes in other node pools, use the `version` attribute on the node pool.
     */
    @JvmName("jnvuwgnunecymomy")
    public suspend fun nodeVersion(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nodeVersion = mapped
    }

    /**
     * @param value Configuration for the [cluster upgrade notifications](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-upgrade-notifications) feature. Structure is documented below.
     */
    @JvmName("bvnamxjqgpcccaxk")
    public suspend fun notificationConfig(`value`: ClusterNotificationConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.notificationConfig = mapped
    }

    /**
     * @param argument Configuration for the [cluster upgrade notifications](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-upgrade-notifications) feature. Structure is documented below.
     */
    @JvmName("fxydeuvwwkhxqypa")
    public suspend fun notificationConfig(argument: suspend ClusterNotificationConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterNotificationConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.notificationConfig = mapped
    }

    /**
     * @param value Configuration for the
     * [PodSecurityPolicy](https://cloud.google.com/kubernetes-engine/docs/how-to/pod-security-policies) feature.
     * Structure is documented below.
     */
    @JvmName("vmbhuvkcsalqbgyu")
    public suspend fun podSecurityPolicyConfig(`value`: ClusterPodSecurityPolicyConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.podSecurityPolicyConfig = mapped
    }

    /**
     * @param argument Configuration for the
     * [PodSecurityPolicy](https://cloud.google.com/kubernetes-engine/docs/how-to/pod-security-policies) feature.
     * Structure is documented below.
     */
    @JvmName("muvvtrgjodsqwdoc")
    public suspend fun podSecurityPolicyConfig(argument: suspend ClusterPodSecurityPolicyConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterPodSecurityPolicyConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.podSecurityPolicyConfig = mapped
    }

    /**
     * @param value Configuration for [private clusters](https://cloud.google.com/kubernetes-engine/docs/how-to/private-clusters),
     * clusters with private nodes. Structure is documented below.
     */
    @JvmName("hiqgifxjpdseqdhg")
    public suspend fun privateClusterConfig(`value`: ClusterPrivateClusterConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.privateClusterConfig = mapped
    }

    /**
     * @param argument Configuration for [private clusters](https://cloud.google.com/kubernetes-engine/docs/how-to/private-clusters),
     * clusters with private nodes. Structure is documented below.
     */
    @JvmName("dqaxqwbgdqsfedyg")
    public suspend fun privateClusterConfig(argument: suspend ClusterPrivateClusterConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterPrivateClusterConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.privateClusterConfig = mapped
    }

    /**
     * @param value The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4).
     */
    @JvmName("lbpghivtpysvbxop")
    public suspend fun privateIpv6GoogleAccess(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.privateIpv6GoogleAccess = mapped
    }

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

    /**
     * @param value Enable/Disable Protect API features for the cluster. Structure is documented below.
     */
    @JvmName("vbtcrsusqykdasmp")
    public suspend fun protectConfig(`value`: ClusterProtectConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.protectConfig = mapped
    }

    /**
     * @param argument Enable/Disable Protect API features for the cluster. Structure is documented below.
     */
    @JvmName("dswtadjnggribqfs")
    public suspend fun protectConfig(argument: suspend ClusterProtectConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterProtectConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.protectConfig = mapped
    }

    /**
     * @param value Configuration options for the [Release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels)
     * feature, which provide more control over automatic upgrades of your GKE clusters.
     * When updating this field, GKE imposes specific version requirements. See
     * [Selecting a new release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels#selecting_a_new_release_channel)
     * for more details; the `gcp.container.getEngineVersions` datasource can provide
     * the default version for a channel. Note that removing the `release_channel`
     * field from your config will cause the provider to stop managing your cluster's
     * release channel, but will not unenroll it. Instead, use the `"UNSPECIFIED"`
     * channel. Structure is documented below.
     */
    @JvmName("hhxbrtldmfyaseeg")
    public suspend fun releaseChannel(`value`: ClusterReleaseChannelArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.releaseChannel = mapped
    }

    /**
     * @param argument Configuration options for the [Release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels)
     * feature, which provide more control over automatic upgrades of your GKE clusters.
     * When updating this field, GKE imposes specific version requirements. See
     * [Selecting a new release channel](https://cloud.google.com/kubernetes-engine/docs/concepts/release-channels#selecting_a_new_release_channel)
     * for more details; the `gcp.container.getEngineVersions` datasource can provide
     * the default version for a channel. Note that removing the `release_channel`
     * field from your config will cause the provider to stop managing your cluster's
     * release channel, but will not unenroll it. Instead, use the `"UNSPECIFIED"`
     * channel. Structure is documented below.
     */
    @JvmName("stkuonegcoahvukq")
    public suspend fun releaseChannel(argument: suspend ClusterReleaseChannelArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterReleaseChannelArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.releaseChannel = mapped
    }

    /**
     * @param value If `true`, deletes the default node
     * pool upon cluster creation. If you're using `gcp.container.NodePool`
     * resources with no default node pool, this should be set to `true`, alongside
     * setting `initial_node_count` to at least `1`.
     */
    @JvmName("jtwmjdotbrpfobqv")
    public suspend fun removeDefaultNodePool(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.removeDefaultNodePool = mapped
    }

    /**
     * @param value The GCE resource labels (a map of key/value pairs) to be applied to the cluster.
     */
    @JvmName("pmxarkriwsqfgjen")
    public suspend fun resourceLabels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.resourceLabels = mapped
    }

    /**
     * @param values The GCE resource labels (a map of key/value pairs) to be applied to the cluster.
     */
    @JvmName("drwhlnrnnuxbhbkr")
    public fun resourceLabels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.resourceLabels = mapped
    }

    /**
     * @param value Configuration for the
     * [ResourceUsageExportConfig](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-usage-metering) feature.
     * Structure is documented below.
     */
    @JvmName("yceurqsgposkcore")
    public suspend fun resourceUsageExportConfig(`value`: ClusterResourceUsageExportConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.resourceUsageExportConfig = mapped
    }

    /**
     * @param argument Configuration for the
     * [ResourceUsageExportConfig](https://cloud.google.com/kubernetes-engine/docs/how-to/cluster-usage-metering) feature.
     * Structure is documented below.
     */
    @JvmName("dflnucxgvgerrpuk")
    public suspend fun resourceUsageExportConfig(argument: suspend ClusterResourceUsageExportConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterResourceUsageExportConfigArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.resourceUsageExportConfig = mapped
    }

    /**
     * @param value Enable/Disable Security Posture API features for the cluster. Structure is documented below.
     */
    @JvmName("tgiweiodbwqpjcep")
    public suspend fun securityPostureConfig(`value`: ClusterSecurityPostureConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.securityPostureConfig = mapped
    }

    /**
     * @param argument Enable/Disable Security Posture API features for the cluster. Structure is documented below.
     */
    @JvmName("fisblvsttwpovkpd")
    public suspend fun securityPostureConfig(argument: suspend ClusterSecurityPostureConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterSecurityPostureConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.securityPostureConfig = mapped
    }

    /**
     * @param value Structure is documented below.
     */
    @JvmName("aymkivjqhxollgni")
    public suspend fun serviceExternalIpsConfig(`value`: ClusterServiceExternalIpsConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.serviceExternalIpsConfig = mapped
    }

    /**
     * @param argument Structure is documented below.
     */
    @JvmName("djucyrxadkvxmmrq")
    public suspend fun serviceExternalIpsConfig(argument: suspend ClusterServiceExternalIpsConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterServiceExternalIpsConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.serviceExternalIpsConfig = mapped
    }

    /**
     * @param value The name or self_link of the Google Compute Engine
     * subnetwork in which the cluster's instances are launched.
     */
    @JvmName("mlnxakmwlcvglojb")
    public suspend fun subnetwork(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.subnetwork = mapped
    }

    /**
     * @param value TPU configuration for the cluster.
     */
    @JvmName("sakybnpikcpasuix")
    public suspend fun tpuConfig(`value`: ClusterTpuConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.tpuConfig = mapped
    }

    /**
     * @param argument TPU configuration for the cluster.
     */
    @JvmName("nrhcwxlmvyjxxgsj")
    public suspend fun tpuConfig(argument: suspend ClusterTpuConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterTpuConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.tpuConfig = mapped
    }

    /**
     * @param value Vertical Pod Autoscaling automatically adjusts the resources of pods controlled by it.
     * Structure is documented below.
     */
    @JvmName("guvcnksppdiihndu")
    public suspend fun verticalPodAutoscaling(`value`: ClusterVerticalPodAutoscalingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.verticalPodAutoscaling = mapped
    }

    /**
     * @param argument Vertical Pod Autoscaling automatically adjusts the resources of pods controlled by it.
     * Structure is documented below.
     */
    @JvmName("ltxyxvataamtpfeb")
    public suspend fun verticalPodAutoscaling(argument: suspend ClusterVerticalPodAutoscalingArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterVerticalPodAutoscalingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.verticalPodAutoscaling = mapped
    }

    /**
     * @param value Configuration for [direct-path (via ALTS) with workload identity.](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#workloadaltsconfig). Structure is documented below.
     * The `default_snat_status` block supports
     */
    @JvmName("voodydkxseyxqtjy")
    public suspend fun workloadAltsConfig(`value`: ClusterWorkloadAltsConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.workloadAltsConfig = mapped
    }

    /**
     * @param argument Configuration for [direct-path (via ALTS) with workload identity.](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#workloadaltsconfig). Structure is documented below.
     * The `default_snat_status` block supports
     */
    @JvmName("efbtacurlrqcovwa")
    public suspend fun workloadAltsConfig(argument: suspend ClusterWorkloadAltsConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterWorkloadAltsConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.workloadAltsConfig = mapped
    }

    /**
     * @param value Workload Identity allows Kubernetes service accounts to act as a user-managed
     * [Google IAM Service Account](https://cloud.google.com/iam/docs/service-accounts#user-managed_service_accounts).
     * Structure is documented below.
     */
    @JvmName("lixekpllnuityudl")
    public suspend fun workloadIdentityConfig(`value`: ClusterWorkloadIdentityConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.workloadIdentityConfig = mapped
    }

    /**
     * @param argument Workload Identity allows Kubernetes service accounts to act as a user-managed
     * [Google IAM Service Account](https://cloud.google.com/iam/docs/service-accounts#user-managed_service_accounts).
     * Structure is documented below.
     */
    @JvmName("jyvoduohhdhlushx")
    public suspend fun workloadIdentityConfig(argument: suspend ClusterWorkloadIdentityConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterWorkloadIdentityConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.workloadIdentityConfig = mapped
    }

    internal fun build(): ClusterArgs = ClusterArgs(
        addonsConfig = addonsConfig,
        allowNetAdmin = allowNetAdmin,
        authenticatorGroupsConfig = authenticatorGroupsConfig,
        binaryAuthorization = binaryAuthorization,
        clusterAutoscaling = clusterAutoscaling,
        clusterIpv4Cidr = clusterIpv4Cidr,
        clusterTelemetry = clusterTelemetry,
        confidentialNodes = confidentialNodes,
        costManagementConfig = costManagementConfig,
        databaseEncryption = databaseEncryption,
        datapathProvider = datapathProvider,
        defaultMaxPodsPerNode = defaultMaxPodsPerNode,
        defaultSnatStatus = defaultSnatStatus,
        deletionProtection = deletionProtection,
        description = description,
        dnsConfig = dnsConfig,
        enableAutopilot = enableAutopilot,
        enableCiliumClusterwideNetworkPolicy = enableCiliumClusterwideNetworkPolicy,
        enableFqdnNetworkPolicy = enableFqdnNetworkPolicy,
        enableIntranodeVisibility = enableIntranodeVisibility,
        enableK8sBetaApis = enableK8sBetaApis,
        enableKubernetesAlpha = enableKubernetesAlpha,
        enableL4IlbSubsetting = enableL4IlbSubsetting,
        enableLegacyAbac = enableLegacyAbac,
        enableMultiNetworking = enableMultiNetworking,
        enableShieldedNodes = enableShieldedNodes,
        enableTpu = enableTpu,
        fleet = fleet,
        gatewayApiConfig = gatewayApiConfig,
        identityServiceConfig = identityServiceConfig,
        initialNodeCount = initialNodeCount,
        ipAllocationPolicy = ipAllocationPolicy,
        location = location,
        loggingConfig = loggingConfig,
        loggingService = loggingService,
        maintenancePolicy = maintenancePolicy,
        masterAuth = masterAuth,
        masterAuthorizedNetworksConfig = masterAuthorizedNetworksConfig,
        meshCertificates = meshCertificates,
        minMasterVersion = minMasterVersion,
        monitoringConfig = monitoringConfig,
        monitoringService = monitoringService,
        name = name,
        network = network,
        networkPolicy = networkPolicy,
        networkingMode = networkingMode,
        nodeConfig = nodeConfig,
        nodeLocations = nodeLocations,
        nodePoolAutoConfig = nodePoolAutoConfig,
        nodePoolDefaults = nodePoolDefaults,
        nodePools = nodePools,
        nodeVersion = nodeVersion,
        notificationConfig = notificationConfig,
        podSecurityPolicyConfig = podSecurityPolicyConfig,
        privateClusterConfig = privateClusterConfig,
        privateIpv6GoogleAccess = privateIpv6GoogleAccess,
        project = project,
        protectConfig = protectConfig,
        releaseChannel = releaseChannel,
        removeDefaultNodePool = removeDefaultNodePool,
        resourceLabels = resourceLabels,
        resourceUsageExportConfig = resourceUsageExportConfig,
        securityPostureConfig = securityPostureConfig,
        serviceExternalIpsConfig = serviceExternalIpsConfig,
        subnetwork = subnetwork,
        tpuConfig = tpuConfig,
        verticalPodAutoscaling = verticalPodAutoscaling,
        workloadAltsConfig = workloadAltsConfig,
        workloadIdentityConfig = workloadIdentityConfig,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy