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

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

package com.pulumi.gcp.edgecontainer.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.edgecontainer.ClusterArgs.builder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterAuthorizationArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterAuthorizationArgsBuilder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterControlPlaneArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterControlPlaneArgsBuilder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterControlPlaneEncryptionArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterControlPlaneEncryptionArgsBuilder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterFleetArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterFleetArgsBuilder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterMaintenancePolicyArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterMaintenancePolicyArgsBuilder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterNetworkingArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterNetworkingArgsBuilder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterSystemAddonsConfigArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.ClusterSystemAddonsConfigArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
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

/**
 * Cluster contains information about a Google Distributed Cloud Edge Kubernetes cluster.
 * To get more information about Cluster, see:
 * * [API documentation](https://cloud.google.com/distributed-cloud/edge/latest/docs/reference/container/rest/v1/projects.locations.clusters)
 * * How-to Guides
 *     * [Create and manage clusters](https://cloud.google.com/distributed-cloud/edge/latest/docs/clusters)
 * ## Example Usage
 * ### Edgecontainer Cluster
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const project = gcp.organizations.getProject({});
 * const _default = new gcp.edgecontainer.Cluster("default", {
 *     name: "basic-cluster",
 *     location: "us-central1",
 *     authorization: {
 *         adminUsers: {
 *             username: "[email protected]",
 *         },
 *     },
 *     networking: {
 *         clusterIpv4CidrBlocks: ["10.0.0.0/16"],
 *         servicesIpv4CidrBlocks: ["10.1.0.0/16"],
 *     },
 *     fleet: {
 *         project: project.then(project => `projects/${project.number}`),
 *     },
 *     labels: {
 *         my_key: "my_val",
 *         other_key: "other_val",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * project = gcp.organizations.get_project()
 * default = gcp.edgecontainer.Cluster("default",
 *     name="basic-cluster",
 *     location="us-central1",
 *     authorization=gcp.edgecontainer.ClusterAuthorizationArgs(
 *         admin_users=gcp.edgecontainer.ClusterAuthorizationAdminUsersArgs(
 *             username="[email protected]",
 *         ),
 *     ),
 *     networking=gcp.edgecontainer.ClusterNetworkingArgs(
 *         cluster_ipv4_cidr_blocks=["10.0.0.0/16"],
 *         services_ipv4_cidr_blocks=["10.1.0.0/16"],
 *     ),
 *     fleet=gcp.edgecontainer.ClusterFleetArgs(
 *         project=f"projects/{project.number}",
 *     ),
 *     labels={
 *         "my_key": "my_val",
 *         "other_key": "other_val",
 *     })
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var project = Gcp.Organizations.GetProject.Invoke();
 *     var @default = new Gcp.EdgeContainer.Cluster("default", new()
 *     {
 *         Name = "basic-cluster",
 *         Location = "us-central1",
 *         Authorization = new Gcp.EdgeContainer.Inputs.ClusterAuthorizationArgs
 *         {
 *             AdminUsers = new Gcp.EdgeContainer.Inputs.ClusterAuthorizationAdminUsersArgs
 *             {
 *                 Username = "[email protected]",
 *             },
 *         },
 *         Networking = new Gcp.EdgeContainer.Inputs.ClusterNetworkingArgs
 *         {
 *             ClusterIpv4CidrBlocks = new[]
 *             {
 *                 "10.0.0.0/16",
 *             },
 *             ServicesIpv4CidrBlocks = new[]
 *             {
 *                 "10.1.0.0/16",
 *             },
 *         },
 *         Fleet = new Gcp.EdgeContainer.Inputs.ClusterFleetArgs
 *         {
 *             Project = $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}",
 *         },
 *         Labels =
 *         {
 *             { "my_key", "my_val" },
 *             { "other_key", "other_val" },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/edgecontainer"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		project, err := organizations.LookupProject(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = edgecontainer.NewCluster(ctx, "default", &edgecontainer.ClusterArgs{
 * 			Name:     pulumi.String("basic-cluster"),
 * 			Location: pulumi.String("us-central1"),
 * 			Authorization: &edgecontainer.ClusterAuthorizationArgs{
 * 				AdminUsers: &edgecontainer.ClusterAuthorizationAdminUsersArgs{
 * 					Username: pulumi.String("[email protected]"),
 * 				},
 * 			},
 * 			Networking: &edgecontainer.ClusterNetworkingArgs{
 * 				ClusterIpv4CidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.0.0.0/16"),
 * 				},
 * 				ServicesIpv4CidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.1.0.0/16"),
 * 				},
 * 			},
 * 			Fleet: &edgecontainer.ClusterFleetArgs{
 * 				Project: pulumi.String(fmt.Sprintf("projects/%v", project.Number)),
 * 			},
 * 			Labels: pulumi.StringMap{
 * 				"my_key":    pulumi.String("my_val"),
 * 				"other_key": pulumi.String("other_val"),
 * 			},
 * 		})
 * 		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.organizations.OrganizationsFunctions;
 * import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
 * import com.pulumi.gcp.edgecontainer.Cluster;
 * import com.pulumi.gcp.edgecontainer.ClusterArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterAuthorizationArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterAuthorizationAdminUsersArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterNetworkingArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterFleetArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         final var project = OrganizationsFunctions.getProject();
 *         var default_ = new Cluster("default", ClusterArgs.builder()
 *             .name("basic-cluster")
 *             .location("us-central1")
 *             .authorization(ClusterAuthorizationArgs.builder()
 *                 .adminUsers(ClusterAuthorizationAdminUsersArgs.builder()
 *                     .username("[email protected]")
 *                     .build())
 *                 .build())
 *             .networking(ClusterNetworkingArgs.builder()
 *                 .clusterIpv4CidrBlocks("10.0.0.0/16")
 *                 .servicesIpv4CidrBlocks("10.1.0.0/16")
 *                 .build())
 *             .fleet(ClusterFleetArgs.builder()
 *                 .project(String.format("projects/%s", project.applyValue(getProjectResult -> getProjectResult.number())))
 *                 .build())
 *             .labels(Map.ofEntries(
 *                 Map.entry("my_key", "my_val"),
 *                 Map.entry("other_key", "other_val")
 *             ))
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   default:
 *     type: gcp:edgecontainer:Cluster
 *     properties:
 *       name: basic-cluster
 *       location: us-central1
 *       authorization:
 *         adminUsers:
 *           username: [email protected]
 *       networking:
 *         clusterIpv4CidrBlocks:
 *           - 10.0.0.0/16
 *         servicesIpv4CidrBlocks:
 *           - 10.1.0.0/16
 *       fleet:
 *         project: projects/${project.number}
 *       labels:
 *         my_key: my_val
 *         other_key: other_val
 * variables:
 *   project:
 *     fn::invoke:
 *       Function: gcp:organizations:getProject
 *       Arguments: {}
 * ```
 * 
 * ### Edgecontainer Cluster With Maintenance Window
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const project = gcp.organizations.getProject({});
 * const _default = new gcp.edgecontainer.Cluster("default", {
 *     name: "cluster-with-maintenance",
 *     location: "us-central1",
 *     authorization: {
 *         adminUsers: {
 *             username: "[email protected]",
 *         },
 *     },
 *     networking: {
 *         clusterIpv4CidrBlocks: ["10.0.0.0/16"],
 *         servicesIpv4CidrBlocks: ["10.1.0.0/16"],
 *     },
 *     fleet: {
 *         project: project.then(project => `projects/${project.number}`),
 *     },
 *     maintenancePolicy: {
 *         window: {
 *             recurringWindow: {
 *                 window: {
 *                     startTime: "2023-01-01T08:00:00Z",
 *                     endTime: "2023-01-01T17:00:00Z",
 *                 },
 *                 recurrence: "FREQ=WEEKLY;BYDAY=SA",
 *             },
 *         },
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * project = gcp.organizations.get_project()
 * default = gcp.edgecontainer.Cluster("default",
 *     name="cluster-with-maintenance",
 *     location="us-central1",
 *     authorization=gcp.edgecontainer.ClusterAuthorizationArgs(
 *         admin_users=gcp.edgecontainer.ClusterAuthorizationAdminUsersArgs(
 *             username="[email protected]",
 *         ),
 *     ),
 *     networking=gcp.edgecontainer.ClusterNetworkingArgs(
 *         cluster_ipv4_cidr_blocks=["10.0.0.0/16"],
 *         services_ipv4_cidr_blocks=["10.1.0.0/16"],
 *     ),
 *     fleet=gcp.edgecontainer.ClusterFleetArgs(
 *         project=f"projects/{project.number}",
 *     ),
 *     maintenance_policy=gcp.edgecontainer.ClusterMaintenancePolicyArgs(
 *         window=gcp.edgecontainer.ClusterMaintenancePolicyWindowArgs(
 *             recurring_window=gcp.edgecontainer.ClusterMaintenancePolicyWindowRecurringWindowArgs(
 *                 window=gcp.edgecontainer.ClusterMaintenancePolicyWindowRecurringWindowWindowArgs(
 *                     start_time="2023-01-01T08:00:00Z",
 *                     end_time="2023-01-01T17:00:00Z",
 *                 ),
 *                 recurrence="FREQ=WEEKLY;BYDAY=SA",
 *             ),
 *         ),
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var project = Gcp.Organizations.GetProject.Invoke();
 *     var @default = new Gcp.EdgeContainer.Cluster("default", new()
 *     {
 *         Name = "cluster-with-maintenance",
 *         Location = "us-central1",
 *         Authorization = new Gcp.EdgeContainer.Inputs.ClusterAuthorizationArgs
 *         {
 *             AdminUsers = new Gcp.EdgeContainer.Inputs.ClusterAuthorizationAdminUsersArgs
 *             {
 *                 Username = "[email protected]",
 *             },
 *         },
 *         Networking = new Gcp.EdgeContainer.Inputs.ClusterNetworkingArgs
 *         {
 *             ClusterIpv4CidrBlocks = new[]
 *             {
 *                 "10.0.0.0/16",
 *             },
 *             ServicesIpv4CidrBlocks = new[]
 *             {
 *                 "10.1.0.0/16",
 *             },
 *         },
 *         Fleet = new Gcp.EdgeContainer.Inputs.ClusterFleetArgs
 *         {
 *             Project = $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}",
 *         },
 *         MaintenancePolicy = new Gcp.EdgeContainer.Inputs.ClusterMaintenancePolicyArgs
 *         {
 *             Window = new Gcp.EdgeContainer.Inputs.ClusterMaintenancePolicyWindowArgs
 *             {
 *                 RecurringWindow = new Gcp.EdgeContainer.Inputs.ClusterMaintenancePolicyWindowRecurringWindowArgs
 *                 {
 *                     Window = new Gcp.EdgeContainer.Inputs.ClusterMaintenancePolicyWindowRecurringWindowWindowArgs
 *                     {
 *                         StartTime = "2023-01-01T08:00:00Z",
 *                         EndTime = "2023-01-01T17:00:00Z",
 *                     },
 *                     Recurrence = "FREQ=WEEKLY;BYDAY=SA",
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/edgecontainer"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		project, err := organizations.LookupProject(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = edgecontainer.NewCluster(ctx, "default", &edgecontainer.ClusterArgs{
 * 			Name:     pulumi.String("cluster-with-maintenance"),
 * 			Location: pulumi.String("us-central1"),
 * 			Authorization: &edgecontainer.ClusterAuthorizationArgs{
 * 				AdminUsers: &edgecontainer.ClusterAuthorizationAdminUsersArgs{
 * 					Username: pulumi.String("[email protected]"),
 * 				},
 * 			},
 * 			Networking: &edgecontainer.ClusterNetworkingArgs{
 * 				ClusterIpv4CidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.0.0.0/16"),
 * 				},
 * 				ServicesIpv4CidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.1.0.0/16"),
 * 				},
 * 			},
 * 			Fleet: &edgecontainer.ClusterFleetArgs{
 * 				Project: pulumi.String(fmt.Sprintf("projects/%v", project.Number)),
 * 			},
 * 			MaintenancePolicy: &edgecontainer.ClusterMaintenancePolicyArgs{
 * 				Window: &edgecontainer.ClusterMaintenancePolicyWindowArgs{
 * 					RecurringWindow: &edgecontainer.ClusterMaintenancePolicyWindowRecurringWindowArgs{
 * 						Window: &edgecontainer.ClusterMaintenancePolicyWindowRecurringWindowWindowArgs{
 * 							StartTime: pulumi.String("2023-01-01T08:00:00Z"),
 * 							EndTime:   pulumi.String("2023-01-01T17:00:00Z"),
 * 						},
 * 						Recurrence: pulumi.String("FREQ=WEEKLY;BYDAY=SA"),
 * 					},
 * 				},
 * 			},
 * 		})
 * 		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.organizations.OrganizationsFunctions;
 * import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
 * import com.pulumi.gcp.edgecontainer.Cluster;
 * import com.pulumi.gcp.edgecontainer.ClusterArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterAuthorizationArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterAuthorizationAdminUsersArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterNetworkingArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterFleetArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterMaintenancePolicyArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterMaintenancePolicyWindowArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterMaintenancePolicyWindowRecurringWindowArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterMaintenancePolicyWindowRecurringWindowWindowArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         final var project = OrganizationsFunctions.getProject();
 *         var default_ = new Cluster("default", ClusterArgs.builder()
 *             .name("cluster-with-maintenance")
 *             .location("us-central1")
 *             .authorization(ClusterAuthorizationArgs.builder()
 *                 .adminUsers(ClusterAuthorizationAdminUsersArgs.builder()
 *                     .username("[email protected]")
 *                     .build())
 *                 .build())
 *             .networking(ClusterNetworkingArgs.builder()
 *                 .clusterIpv4CidrBlocks("10.0.0.0/16")
 *                 .servicesIpv4CidrBlocks("10.1.0.0/16")
 *                 .build())
 *             .fleet(ClusterFleetArgs.builder()
 *                 .project(String.format("projects/%s", project.applyValue(getProjectResult -> getProjectResult.number())))
 *                 .build())
 *             .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
 *                 .window(ClusterMaintenancePolicyWindowArgs.builder()
 *                     .recurringWindow(ClusterMaintenancePolicyWindowRecurringWindowArgs.builder()
 *                         .window(ClusterMaintenancePolicyWindowRecurringWindowWindowArgs.builder()
 *                             .startTime("2023-01-01T08:00:00Z")
 *                             .endTime("2023-01-01T17:00:00Z")
 *                             .build())
 *                         .recurrence("FREQ=WEEKLY;BYDAY=SA")
 *                         .build())
 *                     .build())
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   default:
 *     type: gcp:edgecontainer:Cluster
 *     properties:
 *       name: cluster-with-maintenance
 *       location: us-central1
 *       authorization:
 *         adminUsers:
 *           username: [email protected]
 *       networking:
 *         clusterIpv4CidrBlocks:
 *           - 10.0.0.0/16
 *         servicesIpv4CidrBlocks:
 *           - 10.1.0.0/16
 *       fleet:
 *         project: projects/${project.number}
 *       maintenancePolicy:
 *         window:
 *           recurringWindow:
 *             window:
 *               startTime: 2023-01-01T08:00:00Z
 *               endTime: 2023-01-01T17:00:00Z
 *             recurrence: FREQ=WEEKLY;BYDAY=SA
 * variables:
 *   project:
 *     fn::invoke:
 *       Function: gcp:organizations:getProject
 *       Arguments: {}
 * ```
 * 
 * ### Edgecontainer Local Control Plane Cluster
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const project = gcp.organizations.getProject({});
 * const _default = new gcp.edgecontainer.Cluster("default", {
 *     name: "local-control-plane-cluster",
 *     location: "us-central1",
 *     authorization: {
 *         adminUsers: {
 *             username: "[email protected]",
 *         },
 *     },
 *     networking: {
 *         clusterIpv4CidrBlocks: ["10.0.0.0/16"],
 *         servicesIpv4CidrBlocks: ["10.1.0.0/16"],
 *     },
 *     fleet: {
 *         project: project.then(project => `projects/${project.number}`),
 *     },
 *     externalLoadBalancerIpv4AddressPools: ["10.100.0.0-10.100.0.10"],
 *     controlPlane: {
 *         local: {
 *             nodeLocation: "us-central1-edge-example-edgesite",
 *             nodeCount: 1,
 *             machineFilter: "machine-name",
 *             sharedDeploymentPolicy: "ALLOWED",
 *         },
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * project = gcp.organizations.get_project()
 * default = gcp.edgecontainer.Cluster("default",
 *     name="local-control-plane-cluster",
 *     location="us-central1",
 *     authorization=gcp.edgecontainer.ClusterAuthorizationArgs(
 *         admin_users=gcp.edgecontainer.ClusterAuthorizationAdminUsersArgs(
 *             username="[email protected]",
 *         ),
 *     ),
 *     networking=gcp.edgecontainer.ClusterNetworkingArgs(
 *         cluster_ipv4_cidr_blocks=["10.0.0.0/16"],
 *         services_ipv4_cidr_blocks=["10.1.0.0/16"],
 *     ),
 *     fleet=gcp.edgecontainer.ClusterFleetArgs(
 *         project=f"projects/{project.number}",
 *     ),
 *     external_load_balancer_ipv4_address_pools=["10.100.0.0-10.100.0.10"],
 *     control_plane=gcp.edgecontainer.ClusterControlPlaneArgs(
 *         local=gcp.edgecontainer.ClusterControlPlaneLocalArgs(
 *             node_location="us-central1-edge-example-edgesite",
 *             node_count=1,
 *             machine_filter="machine-name",
 *             shared_deployment_policy="ALLOWED",
 *         ),
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var project = Gcp.Organizations.GetProject.Invoke();
 *     var @default = new Gcp.EdgeContainer.Cluster("default", new()
 *     {
 *         Name = "local-control-plane-cluster",
 *         Location = "us-central1",
 *         Authorization = new Gcp.EdgeContainer.Inputs.ClusterAuthorizationArgs
 *         {
 *             AdminUsers = new Gcp.EdgeContainer.Inputs.ClusterAuthorizationAdminUsersArgs
 *             {
 *                 Username = "[email protected]",
 *             },
 *         },
 *         Networking = new Gcp.EdgeContainer.Inputs.ClusterNetworkingArgs
 *         {
 *             ClusterIpv4CidrBlocks = new[]
 *             {
 *                 "10.0.0.0/16",
 *             },
 *             ServicesIpv4CidrBlocks = new[]
 *             {
 *                 "10.1.0.0/16",
 *             },
 *         },
 *         Fleet = new Gcp.EdgeContainer.Inputs.ClusterFleetArgs
 *         {
 *             Project = $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}",
 *         },
 *         ExternalLoadBalancerIpv4AddressPools = new[]
 *         {
 *             "10.100.0.0-10.100.0.10",
 *         },
 *         ControlPlane = new Gcp.EdgeContainer.Inputs.ClusterControlPlaneArgs
 *         {
 *             Local = new Gcp.EdgeContainer.Inputs.ClusterControlPlaneLocalArgs
 *             {
 *                 NodeLocation = "us-central1-edge-example-edgesite",
 *                 NodeCount = 1,
 *                 MachineFilter = "machine-name",
 *                 SharedDeploymentPolicy = "ALLOWED",
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/edgecontainer"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		project, err := organizations.LookupProject(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = edgecontainer.NewCluster(ctx, "default", &edgecontainer.ClusterArgs{
 * 			Name:     pulumi.String("local-control-plane-cluster"),
 * 			Location: pulumi.String("us-central1"),
 * 			Authorization: &edgecontainer.ClusterAuthorizationArgs{
 * 				AdminUsers: &edgecontainer.ClusterAuthorizationAdminUsersArgs{
 * 					Username: pulumi.String("[email protected]"),
 * 				},
 * 			},
 * 			Networking: &edgecontainer.ClusterNetworkingArgs{
 * 				ClusterIpv4CidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.0.0.0/16"),
 * 				},
 * 				ServicesIpv4CidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.1.0.0/16"),
 * 				},
 * 			},
 * 			Fleet: &edgecontainer.ClusterFleetArgs{
 * 				Project: pulumi.String(fmt.Sprintf("projects/%v", project.Number)),
 * 			},
 * 			ExternalLoadBalancerIpv4AddressPools: pulumi.StringArray{
 * 				pulumi.String("10.100.0.0-10.100.0.10"),
 * 			},
 * 			ControlPlane: &edgecontainer.ClusterControlPlaneArgs{
 * 				Local: &edgecontainer.ClusterControlPlaneLocalArgs{
 * 					NodeLocation:           pulumi.String("us-central1-edge-example-edgesite"),
 * 					NodeCount:              pulumi.Int(1),
 * 					MachineFilter:          pulumi.String("machine-name"),
 * 					SharedDeploymentPolicy: pulumi.String("ALLOWED"),
 * 				},
 * 			},
 * 		})
 * 		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.organizations.OrganizationsFunctions;
 * import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
 * import com.pulumi.gcp.edgecontainer.Cluster;
 * import com.pulumi.gcp.edgecontainer.ClusterArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterAuthorizationArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterAuthorizationAdminUsersArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterNetworkingArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterFleetArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterControlPlaneArgs;
 * import com.pulumi.gcp.edgecontainer.inputs.ClusterControlPlaneLocalArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         final var project = OrganizationsFunctions.getProject();
 *         var default_ = new Cluster("default", ClusterArgs.builder()
 *             .name("local-control-plane-cluster")
 *             .location("us-central1")
 *             .authorization(ClusterAuthorizationArgs.builder()
 *                 .adminUsers(ClusterAuthorizationAdminUsersArgs.builder()
 *                     .username("[email protected]")
 *                     .build())
 *                 .build())
 *             .networking(ClusterNetworkingArgs.builder()
 *                 .clusterIpv4CidrBlocks("10.0.0.0/16")
 *                 .servicesIpv4CidrBlocks("10.1.0.0/16")
 *                 .build())
 *             .fleet(ClusterFleetArgs.builder()
 *                 .project(String.format("projects/%s", project.applyValue(getProjectResult -> getProjectResult.number())))
 *                 .build())
 *             .externalLoadBalancerIpv4AddressPools("10.100.0.0-10.100.0.10")
 *             .controlPlane(ClusterControlPlaneArgs.builder()
 *                 .local(ClusterControlPlaneLocalArgs.builder()
 *                     .nodeLocation("us-central1-edge-example-edgesite")
 *                     .nodeCount(1)
 *                     .machineFilter("machine-name")
 *                     .sharedDeploymentPolicy("ALLOWED")
 *                     .build())
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   default:
 *     type: gcp:edgecontainer:Cluster
 *     properties:
 *       name: local-control-plane-cluster
 *       location: us-central1
 *       authorization:
 *         adminUsers:
 *           username: [email protected]
 *       networking:
 *         clusterIpv4CidrBlocks:
 *           - 10.0.0.0/16
 *         servicesIpv4CidrBlocks:
 *           - 10.1.0.0/16
 *       fleet:
 *         project: projects/${project.number}
 *       externalLoadBalancerIpv4AddressPools:
 *         - 10.100.0.0-10.100.0.10
 *       controlPlane:
 *         local:
 *           nodeLocation: us-central1-edge-example-edgesite
 *           nodeCount: 1
 *           machineFilter: machine-name
 *           sharedDeploymentPolicy: ALLOWED
 * variables:
 *   project:
 *     fn::invoke:
 *       Function: gcp:organizations:getProject
 *       Arguments: {}
 * ```
 * 
 * ## Import
 * Cluster can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{location}}/clusters/{{name}}`
 * * `{{project}}/{{location}}/{{name}}`
 * * `{{location}}/{{name}}`
 * When using the `pulumi import` command, Cluster can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:edgecontainer/cluster:Cluster default projects/{{project}}/locations/{{location}}/clusters/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:edgecontainer/cluster:Cluster default {{project}}/{{location}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:edgecontainer/cluster:Cluster default {{location}}/{{name}}
 * ```
 * @property authorization RBAC policy that will be applied and managed by GEC.
 * Structure is documented below.
 * @property controlPlane The configuration of the cluster control plane.
 * @property controlPlaneEncryption Remote control plane disk encryption options. This field is only used when enabling CMEK support.
 * @property defaultMaxPodsPerNode The default maximum number of pods per node used if a maximum value is not specified explicitly for a node pool in this
 * cluster. If unspecified, the Kubernetes default value will be used.
 * @property externalLoadBalancerIpv4AddressPools Address pools for cluster data plane external load balancing.
 * @property fleet Fleet related configuration.
 * Fleets are a Google Cloud concept for logically organizing clusters,
 * letting you use and manage multi-cluster capabilities and apply
 * consistent policies across your systems.
 * Structure is documented below.
 * @property labels User-defined labels for the edgecloud cluster. **Note**: This field is non-authoritative, and will only manage the
 * labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the
 * resource.
 * @property location The location of the resource.
 * @property maintenancePolicy Cluster-wide maintenance policy configuration.
 * @property name The GDCE cluster name.
 * @property networking Fleet related configuration.
 * Fleets are a Google Cloud concept for logically organizing clusters,
 * letting you use and manage multi-cluster capabilities and apply
 * consistent policies across your systems.
 * Structure is documented below.
 * @property project
 * @property releaseChannel The release channel a cluster is subscribed to. Possible values: ["RELEASE_CHANNEL_UNSPECIFIED", "NONE", "REGULAR"]
 * @property systemAddonsConfig Config that customers are allowed to define for GDCE system add-ons.
 * @property targetVersion (Output)
 * The target version of the cluster.
 */
public data class ClusterArgs(
    public val authorization: Output? = null,
    public val controlPlane: Output? = null,
    public val controlPlaneEncryption: Output? = null,
    public val defaultMaxPodsPerNode: Output? = null,
    public val externalLoadBalancerIpv4AddressPools: Output>? = null,
    public val fleet: Output? = null,
    public val labels: Output>? = null,
    public val location: Output? = null,
    public val maintenancePolicy: Output? = null,
    public val name: Output? = null,
    public val networking: Output? = null,
    public val project: Output? = null,
    public val releaseChannel: Output? = null,
    public val systemAddonsConfig: Output? = null,
    public val targetVersion: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.edgecontainer.ClusterArgs =
        com.pulumi.gcp.edgecontainer.ClusterArgs.builder()
            .authorization(authorization?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .controlPlane(controlPlane?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .controlPlaneEncryption(
                controlPlaneEncryption?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .defaultMaxPodsPerNode(defaultMaxPodsPerNode?.applyValue({ args0 -> args0 }))
            .externalLoadBalancerIpv4AddressPools(
                externalLoadBalancerIpv4AddressPools?.applyValue({ args0 ->
                    args0.map({ args0 -> args0 })
                }),
            )
            .fleet(fleet?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .labels(labels?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .location(location?.applyValue({ args0 -> args0 }))
            .maintenancePolicy(maintenancePolicy?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .name(name?.applyValue({ args0 -> args0 }))
            .networking(networking?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .project(project?.applyValue({ args0 -> args0 }))
            .releaseChannel(releaseChannel?.applyValue({ args0 -> args0 }))
            .systemAddonsConfig(
                systemAddonsConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .targetVersion(targetVersion?.applyValue({ args0 -> args0 })).build()
}

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

    private var controlPlane: Output? = null

    private var controlPlaneEncryption: Output? = null

    private var defaultMaxPodsPerNode: Output? = null

    private var externalLoadBalancerIpv4AddressPools: Output>? = null

    private var fleet: Output? = null

    private var labels: Output>? = null

    private var location: Output? = null

    private var maintenancePolicy: Output? = null

    private var name: Output? = null

    private var networking: Output? = null

    private var project: Output? = null

    private var releaseChannel: Output? = null

    private var systemAddonsConfig: Output? = null

    private var targetVersion: Output? = null

    /**
     * @param value RBAC policy that will be applied and managed by GEC.
     * Structure is documented below.
     */
    @JvmName("nwuylwtvppjaeokn")
    public suspend fun authorization(`value`: Output) {
        this.authorization = value
    }

    /**
     * @param value The configuration of the cluster control plane.
     */
    @JvmName("axvjpejudrtsauat")
    public suspend fun controlPlane(`value`: Output) {
        this.controlPlane = value
    }

    /**
     * @param value Remote control plane disk encryption options. This field is only used when enabling CMEK support.
     */
    @JvmName("edujbvnixoaaxxds")
    public suspend fun controlPlaneEncryption(`value`: Output) {
        this.controlPlaneEncryption = value
    }

    /**
     * @param value The default maximum number of pods per node used if a maximum value is not specified explicitly for a node pool in this
     * cluster. If unspecified, the Kubernetes default value will be used.
     */
    @JvmName("fflsggwnlboytmvx")
    public suspend fun defaultMaxPodsPerNode(`value`: Output) {
        this.defaultMaxPodsPerNode = value
    }

    /**
     * @param value Address pools for cluster data plane external load balancing.
     */
    @JvmName("seijlytgsjxnjkvd")
    public suspend fun externalLoadBalancerIpv4AddressPools(`value`: Output>) {
        this.externalLoadBalancerIpv4AddressPools = value
    }

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

    /**
     * @param values Address pools for cluster data plane external load balancing.
     */
    @JvmName("arhxjfhaooilhgsc")
    public suspend fun externalLoadBalancerIpv4AddressPools(values: List>) {
        this.externalLoadBalancerIpv4AddressPools = Output.all(values)
    }

    /**
     * @param value Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * Structure is documented below.
     */
    @JvmName("vvieyabmmutfdhkw")
    public suspend fun fleet(`value`: Output) {
        this.fleet = value
    }

    /**
     * @param value User-defined labels for the edgecloud cluster. **Note**: This field is non-authoritative, and will only manage the
     * labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the
     * resource.
     */
    @JvmName("fqpgtgnabnfjxoyu")
    public suspend fun labels(`value`: Output>) {
        this.labels = value
    }

    /**
     * @param value The location of the resource.
     */
    @JvmName("vcqsxnbmjfhprjgp")
    public suspend fun location(`value`: Output) {
        this.location = value
    }

    /**
     * @param value Cluster-wide maintenance policy configuration.
     */
    @JvmName("kxfswhuxmpyynwvd")
    public suspend fun maintenancePolicy(`value`: Output) {
        this.maintenancePolicy = value
    }

    /**
     * @param value The GDCE cluster name.
     */
    @JvmName("caobxcharthegqjv")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * Structure is documented below.
     */
    @JvmName("gkchtlqpmkxrwoot")
    public suspend fun networking(`value`: Output) {
        this.networking = value
    }

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

    /**
     * @param value The release channel a cluster is subscribed to. Possible values: ["RELEASE_CHANNEL_UNSPECIFIED", "NONE", "REGULAR"]
     */
    @JvmName("lvtrdywukugsmhmm")
    public suspend fun releaseChannel(`value`: Output) {
        this.releaseChannel = value
    }

    /**
     * @param value Config that customers are allowed to define for GDCE system add-ons.
     */
    @JvmName("plwximcliwmdpica")
    public suspend fun systemAddonsConfig(`value`: Output) {
        this.systemAddonsConfig = value
    }

    /**
     * @param value (Output)
     * The target version of the cluster.
     */
    @JvmName("iqpkvfgoujguuwvc")
    public suspend fun targetVersion(`value`: Output) {
        this.targetVersion = value
    }

    /**
     * @param value RBAC policy that will be applied and managed by GEC.
     * Structure is documented below.
     */
    @JvmName("igfcwcpealcunlgk")
    public suspend fun authorization(`value`: ClusterAuthorizationArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.authorization = mapped
    }

    /**
     * @param argument RBAC policy that will be applied and managed by GEC.
     * Structure is documented below.
     */
    @JvmName("ovtybfpqnstyayta")
    public suspend fun authorization(argument: suspend ClusterAuthorizationArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterAuthorizationArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.authorization = mapped
    }

    /**
     * @param value The configuration of the cluster control plane.
     */
    @JvmName("gwvyijuigjrnqrlx")
    public suspend fun controlPlane(`value`: ClusterControlPlaneArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.controlPlane = mapped
    }

    /**
     * @param argument The configuration of the cluster control plane.
     */
    @JvmName("iowcjqaqhmcfqnax")
    public suspend fun controlPlane(argument: suspend ClusterControlPlaneArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterControlPlaneArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.controlPlane = mapped
    }

    /**
     * @param value Remote control plane disk encryption options. This field is only used when enabling CMEK support.
     */
    @JvmName("qadgpjhkusojexbq")
    public suspend fun controlPlaneEncryption(`value`: ClusterControlPlaneEncryptionArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.controlPlaneEncryption = mapped
    }

    /**
     * @param argument Remote control plane disk encryption options. This field is only used when enabling CMEK support.
     */
    @JvmName("ywiaovgarffeywjj")
    public suspend fun controlPlaneEncryption(argument: suspend ClusterControlPlaneEncryptionArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterControlPlaneEncryptionArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.controlPlaneEncryption = mapped
    }

    /**
     * @param value The default maximum number of pods per node used if a maximum value is not specified explicitly for a node pool in this
     * cluster. If unspecified, the Kubernetes default value will be used.
     */
    @JvmName("psdhvsgqidiuqjqe")
    public suspend fun defaultMaxPodsPerNode(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.defaultMaxPodsPerNode = mapped
    }

    /**
     * @param value Address pools for cluster data plane external load balancing.
     */
    @JvmName("ljjqdjeinxkhnjej")
    public suspend fun externalLoadBalancerIpv4AddressPools(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.externalLoadBalancerIpv4AddressPools = mapped
    }

    /**
     * @param values Address pools for cluster data plane external load balancing.
     */
    @JvmName("wtpqgpsgolafuoni")
    public suspend fun externalLoadBalancerIpv4AddressPools(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.externalLoadBalancerIpv4AddressPools = mapped
    }

    /**
     * @param value Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * Structure is documented below.
     */
    @JvmName("bixuxfdofhfhkpjx")
    public suspend fun fleet(`value`: ClusterFleetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.fleet = mapped
    }

    /**
     * @param argument Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * Structure is documented below.
     */
    @JvmName("evawhukygnnnmesm")
    public suspend fun fleet(argument: suspend ClusterFleetArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterFleetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.fleet = mapped
    }

    /**
     * @param value User-defined labels for the edgecloud cluster. **Note**: This field is non-authoritative, and will only manage the
     * labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the
     * resource.
     */
    @JvmName("fjnacpqnvyrgbexr")
    public suspend fun labels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param values User-defined labels for the edgecloud cluster. **Note**: This field is non-authoritative, and will only manage the
     * labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the
     * resource.
     */
    @JvmName("smgbeqouqaspwdlo")
    public fun labels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param value The location of the resource.
     */
    @JvmName("ilagcdwgovctiygh")
    public suspend fun location(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.location = mapped
    }

    /**
     * @param value Cluster-wide maintenance policy configuration.
     */
    @JvmName("wiclomvoruapkqdy")
    public suspend fun maintenancePolicy(`value`: ClusterMaintenancePolicyArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maintenancePolicy = mapped
    }

    /**
     * @param argument Cluster-wide maintenance policy configuration.
     */
    @JvmName("knlixxjbptnmdwsv")
    public suspend fun maintenancePolicy(argument: suspend ClusterMaintenancePolicyArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterMaintenancePolicyArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.maintenancePolicy = mapped
    }

    /**
     * @param value The GDCE cluster name.
     */
    @JvmName("ygdirkcaicomkycy")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * Structure is documented below.
     */
    @JvmName("swjbbxdvtdmvldur")
    public suspend fun networking(`value`: ClusterNetworkingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.networking = mapped
    }

    /**
     * @param argument Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * Structure is documented below.
     */
    @JvmName("itipxlhqaqgryvry")
    public suspend fun networking(argument: suspend ClusterNetworkingArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterNetworkingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.networking = mapped
    }

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

    /**
     * @param value The release channel a cluster is subscribed to. Possible values: ["RELEASE_CHANNEL_UNSPECIFIED", "NONE", "REGULAR"]
     */
    @JvmName("pndsdsljyoufdkae")
    public suspend fun releaseChannel(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.releaseChannel = mapped
    }

    /**
     * @param value Config that customers are allowed to define for GDCE system add-ons.
     */
    @JvmName("kjfwojvsojdpuoyt")
    public suspend fun systemAddonsConfig(`value`: ClusterSystemAddonsConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.systemAddonsConfig = mapped
    }

    /**
     * @param argument Config that customers are allowed to define for GDCE system add-ons.
     */
    @JvmName("rbgwtgceygarttwg")
    public suspend fun systemAddonsConfig(argument: suspend ClusterSystemAddonsConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ClusterSystemAddonsConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.systemAddonsConfig = mapped
    }

    /**
     * @param value (Output)
     * The target version of the cluster.
     */
    @JvmName("nlinwdxglekkjhsn")
    public suspend fun targetVersion(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.targetVersion = mapped
    }

    internal fun build(): ClusterArgs = ClusterArgs(
        authorization = authorization,
        controlPlane = controlPlane,
        controlPlaneEncryption = controlPlaneEncryption,
        defaultMaxPodsPerNode = defaultMaxPodsPerNode,
        externalLoadBalancerIpv4AddressPools = externalLoadBalancerIpv4AddressPools,
        fleet = fleet,
        labels = labels,
        location = location,
        maintenancePolicy = maintenancePolicy,
        name = name,
        networking = networking,
        project = project,
        releaseChannel = releaseChannel,
        systemAddonsConfig = systemAddonsConfig,
        targetVersion = targetVersion,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy