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

com.pulumi.gcp.edgecontainer.kotlin.VpnConnectionArgs.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.VpnConnectionArgs.builder
import com.pulumi.gcp.edgecontainer.kotlin.inputs.VpnConnectionVpcProjectArgs
import com.pulumi.gcp.edgecontainer.kotlin.inputs.VpnConnectionVpcProjectArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 * A VPN connection
 * To get more information about VpnConnection, see:
 * * [API documentation](https://cloud.google.com/distributed-cloud/edge/latest/docs/reference/container/rest/v1/projects.locations.vpnConnections)
 * * How-to Guides
 *     * [Google Distributed Cloud Edge](https://cloud.google.com/distributed-cloud/edge/latest/docs)
 * ## Example Usage
 * ### Edgecontainer Vpn Connection
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const project = gcp.organizations.getProject({});
 * const cluster = new gcp.edgecontainer.Cluster("cluster", {
 *     name: "default",
 *     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}`),
 *     },
 * });
 * const nodePool = new gcp.edgecontainer.NodePool("node_pool", {
 *     name: "nodepool-1",
 *     cluster: cluster.name,
 *     location: "us-central1",
 *     nodeLocation: "us-central1-edge-example-edgesite",
 *     nodeCount: 3,
 * });
 * const vpc = new gcp.compute.Network("vpc", {name: "example-vpc"});
 * const _default = new gcp.edgecontainer.VpnConnection("default", {
 *     name: "vpn-connection-1",
 *     location: "us-central1",
 *     cluster: pulumi.all([project, cluster.name]).apply(([project, name]) => `projects/${project.number}/locations/us-east1/clusters/${name}`),
 *     vpc: vpc.name,
 *     enableHighAvailability: true,
 *     labels: {
 *         my_key: "my_val",
 *         other_key: "other_val",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * project = gcp.organizations.get_project()
 * cluster = gcp.edgecontainer.Cluster("cluster",
 *     name="default",
 *     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}",
 *     ))
 * node_pool = gcp.edgecontainer.NodePool("node_pool",
 *     name="nodepool-1",
 *     cluster=cluster.name,
 *     location="us-central1",
 *     node_location="us-central1-edge-example-edgesite",
 *     node_count=3)
 * vpc = gcp.compute.Network("vpc", name="example-vpc")
 * default = gcp.edgecontainer.VpnConnection("default",
 *     name="vpn-connection-1",
 *     location="us-central1",
 *     cluster=cluster.name.apply(lambda name: f"projects/{project.number}/locations/us-east1/clusters/{name}"),
 *     vpc=vpc.name,
 *     enable_high_availability=True,
 *     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 cluster = new Gcp.EdgeContainer.Cluster("cluster", new()
 *     {
 *         Name = "default",
 *         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)}",
 *         },
 *     });
 *     var nodePool = new Gcp.EdgeContainer.NodePool("node_pool", new()
 *     {
 *         Name = "nodepool-1",
 *         Cluster = cluster.Name,
 *         Location = "us-central1",
 *         NodeLocation = "us-central1-edge-example-edgesite",
 *         NodeCount = 3,
 *     });
 *     var vpc = new Gcp.Compute.Network("vpc", new()
 *     {
 *         Name = "example-vpc",
 *     });
 *     var @default = new Gcp.EdgeContainer.VpnConnection("default", new()
 *     {
 *         Name = "vpn-connection-1",
 *         Location = "us-central1",
 *         Cluster = Output.Tuple(project, cluster.Name).Apply(values =>
 *         {
 *             var project = values.Item1;
 *             var name = values.Item2;
 *             return $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}/locations/us-east1/clusters/{name}";
 *         }),
 *         Vpc = vpc.Name,
 *         EnableHighAvailability = true,
 *         Labels =
 *         {
 *             { "my_key", "my_val" },
 *             { "other_key", "other_val" },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
 * 	"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
 * 		}
 * 		cluster, err := edgecontainer.NewCluster(ctx, "cluster", &edgecontainer.ClusterArgs{
 * 			Name:     pulumi.String("default"),
 * 			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)),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = edgecontainer.NewNodePool(ctx, "node_pool", &edgecontainer.NodePoolArgs{
 * 			Name:         pulumi.String("nodepool-1"),
 * 			Cluster:      cluster.Name,
 * 			Location:     pulumi.String("us-central1"),
 * 			NodeLocation: pulumi.String("us-central1-edge-example-edgesite"),
 * 			NodeCount:    pulumi.Int(3),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		vpc, err := compute.NewNetwork(ctx, "vpc", &compute.NetworkArgs{
 * 			Name: pulumi.String("example-vpc"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = edgecontainer.NewVpnConnection(ctx, "default", &edgecontainer.VpnConnectionArgs{
 * 			Name:     pulumi.String("vpn-connection-1"),
 * 			Location: pulumi.String("us-central1"),
 * 			Cluster: cluster.Name.ApplyT(func(name string) (string, error) {
 * 				return fmt.Sprintf("projects/%v/locations/us-east1/clusters/%v", project.Number, name), nil
 * 			}).(pulumi.StringOutput),
 * 			Vpc:                    vpc.Name,
 * 			EnableHighAvailability: pulumi.Bool(true),
 * 			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 com.pulumi.gcp.edgecontainer.NodePool;
 * import com.pulumi.gcp.edgecontainer.NodePoolArgs;
 * import com.pulumi.gcp.compute.Network;
 * import com.pulumi.gcp.compute.NetworkArgs;
 * import com.pulumi.gcp.edgecontainer.VpnConnection;
 * import com.pulumi.gcp.edgecontainer.VpnConnectionArgs;
 * 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 cluster = new Cluster("cluster", ClusterArgs.builder()
 *             .name("default")
 *             .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())
 *             .build());
 *         var nodePool = new NodePool("nodePool", NodePoolArgs.builder()
 *             .name("nodepool-1")
 *             .cluster(cluster.name())
 *             .location("us-central1")
 *             .nodeLocation("us-central1-edge-example-edgesite")
 *             .nodeCount(3)
 *             .build());
 *         var vpc = new Network("vpc", NetworkArgs.builder()
 *             .name("example-vpc")
 *             .build());
 *         var default_ = new VpnConnection("default", VpnConnectionArgs.builder()
 *             .name("vpn-connection-1")
 *             .location("us-central1")
 *             .cluster(cluster.name().applyValue(name -> String.format("projects/%s/locations/us-east1/clusters/%s", project.applyValue(getProjectResult -> getProjectResult.number()),name)))
 *             .vpc(vpc.name())
 *             .enableHighAvailability(true)
 *             .labels(Map.ofEntries(
 *                 Map.entry("my_key", "my_val"),
 *                 Map.entry("other_key", "other_val")
 *             ))
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   cluster:
 *     type: gcp:edgecontainer:Cluster
 *     properties:
 *       name: default
 *       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}
 *   nodePool:
 *     type: gcp:edgecontainer:NodePool
 *     name: node_pool
 *     properties:
 *       name: nodepool-1
 *       cluster: ${cluster.name}
 *       location: us-central1
 *       nodeLocation: us-central1-edge-example-edgesite
 *       nodeCount: 3
 *   default:
 *     type: gcp:edgecontainer:VpnConnection
 *     properties:
 *       name: vpn-connection-1
 *       location: us-central1
 *       cluster: projects/${project.number}/locations/us-east1/clusters/${cluster.name}
 *       vpc: ${vpc.name}
 *       enableHighAvailability: true
 *       labels:
 *         my_key: my_val
 *         other_key: other_val
 *   vpc:
 *     type: gcp:compute:Network
 *     properties:
 *       name: example-vpc
 * variables:
 *   project:
 *     fn::invoke:
 *       Function: gcp:organizations:getProject
 *       Arguments: {}
 * ```
 * 
 * ## Import
 * VpnConnection can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{location}}/vpnConnections/{{name}}`
 * * `{{project}}/{{location}}/{{name}}`
 * * `{{location}}/{{name}}`
 * When using the `pulumi import` command, VpnConnection can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:edgecontainer/vpnConnection:VpnConnection default projects/{{project}}/locations/{{location}}/vpnConnections/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:edgecontainer/vpnConnection:VpnConnection default {{project}}/{{location}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:edgecontainer/vpnConnection:VpnConnection default {{location}}/{{name}}
 * ```
 * @property cluster The canonical Cluster name to connect to. It is in the form of projects/{project}/locations/{location}/clusters/{cluster}.
 * @property enableHighAvailability Whether this VPN connection has HA enabled on cluster side. If enabled, when creating VPN connection we will attempt to use 2 ANG floating IPs.
 * @property labels Labels associated with this resource.
 * **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 Google Cloud Platform location.
 * - - -
 * @property name The resource name of VPN connection
 * @property natGatewayIp NAT gateway IP, or WAN IP address. If a customer has multiple NAT IPs, the customer needs to configure NAT such that only one external IP maps to the GMEC Anthos cluster.
 * This is empty if NAT is not used.
 * @property project The ID of the project in which the resource belongs.
 * If it is not provided, the provider project is used.
 * @property router The VPN connection Cloud Router name.
 * @property vpc The network ID of VPC to connect to.
 * @property vpcProject Project detail of the VPC network. Required if VPC is in a different project than the cluster project.
 * Structure is documented below.
 */
public data class VpnConnectionArgs(
    public val cluster: Output? = null,
    public val enableHighAvailability: Output? = null,
    public val labels: Output>? = null,
    public val location: Output? = null,
    public val name: Output? = null,
    public val natGatewayIp: Output? = null,
    public val project: Output? = null,
    public val router: Output? = null,
    public val vpc: Output? = null,
    public val vpcProject: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.edgecontainer.VpnConnectionArgs =
        com.pulumi.gcp.edgecontainer.VpnConnectionArgs.builder()
            .cluster(cluster?.applyValue({ args0 -> args0 }))
            .enableHighAvailability(enableHighAvailability?.applyValue({ args0 -> args0 }))
            .labels(labels?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .location(location?.applyValue({ args0 -> args0 }))
            .name(name?.applyValue({ args0 -> args0 }))
            .natGatewayIp(natGatewayIp?.applyValue({ args0 -> args0 }))
            .project(project?.applyValue({ args0 -> args0 }))
            .router(router?.applyValue({ args0 -> args0 }))
            .vpc(vpc?.applyValue({ args0 -> args0 }))
            .vpcProject(vpcProject?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) })).build()
}

/**
 * Builder for [VpnConnectionArgs].
 */
@PulumiTagMarker
public class VpnConnectionArgsBuilder internal constructor() {
    private var cluster: Output? = null

    private var enableHighAvailability: Output? = null

    private var labels: Output>? = null

    private var location: Output? = null

    private var name: Output? = null

    private var natGatewayIp: Output? = null

    private var project: Output? = null

    private var router: Output? = null

    private var vpc: Output? = null

    private var vpcProject: Output? = null

    /**
     * @param value The canonical Cluster name to connect to. It is in the form of projects/{project}/locations/{location}/clusters/{cluster}.
     */
    @JvmName("rulmvkknrsyndkqj")
    public suspend fun cluster(`value`: Output) {
        this.cluster = value
    }

    /**
     * @param value Whether this VPN connection has HA enabled on cluster side. If enabled, when creating VPN connection we will attempt to use 2 ANG floating IPs.
     */
    @JvmName("okabymatljabuqig")
    public suspend fun enableHighAvailability(`value`: Output) {
        this.enableHighAvailability = value
    }

    /**
     * @param value Labels associated with this resource.
     * **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("iewbyrtamhvbldfj")
    public suspend fun labels(`value`: Output>) {
        this.labels = value
    }

    /**
     * @param value Google Cloud Platform location.
     * - - -
     */
    @JvmName("ljbaehynuymfiowl")
    public suspend fun location(`value`: Output) {
        this.location = value
    }

    /**
     * @param value The resource name of VPN connection
     */
    @JvmName("jhottgyxhokqhpai")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value NAT gateway IP, or WAN IP address. If a customer has multiple NAT IPs, the customer needs to configure NAT such that only one external IP maps to the GMEC Anthos cluster.
     * This is empty if NAT is not used.
     */
    @JvmName("lsnfivokydkajhey")
    public suspend fun natGatewayIp(`value`: Output) {
        this.natGatewayIp = value
    }

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

    /**
     * @param value The VPN connection Cloud Router name.
     */
    @JvmName("ocunpahnsiuufgxg")
    public suspend fun router(`value`: Output) {
        this.router = value
    }

    /**
     * @param value The network ID of VPC to connect to.
     */
    @JvmName("bfvkkpjxirmpofaj")
    public suspend fun vpc(`value`: Output) {
        this.vpc = value
    }

    /**
     * @param value Project detail of the VPC network. Required if VPC is in a different project than the cluster project.
     * Structure is documented below.
     */
    @JvmName("geyiwmxakfiqefhg")
    public suspend fun vpcProject(`value`: Output) {
        this.vpcProject = value
    }

    /**
     * @param value The canonical Cluster name to connect to. It is in the form of projects/{project}/locations/{location}/clusters/{cluster}.
     */
    @JvmName("oumjlpaaafsvukxm")
    public suspend fun cluster(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.cluster = mapped
    }

    /**
     * @param value Whether this VPN connection has HA enabled on cluster side. If enabled, when creating VPN connection we will attempt to use 2 ANG floating IPs.
     */
    @JvmName("iiqtbugbypexgbwr")
    public suspend fun enableHighAvailability(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableHighAvailability = mapped
    }

    /**
     * @param value Labels associated with this resource.
     * **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("bykisgdxhrekbjmw")
    public suspend fun labels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param values Labels associated with this resource.
     * **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("switrfhhpuvtqsoh")
    public fun labels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.labels = mapped
    }

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

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

    /**
     * @param value NAT gateway IP, or WAN IP address. If a customer has multiple NAT IPs, the customer needs to configure NAT such that only one external IP maps to the GMEC Anthos cluster.
     * This is empty if NAT is not used.
     */
    @JvmName("mcafkydmdgnqgoow")
    public suspend fun natGatewayIp(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.natGatewayIp = mapped
    }

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

    /**
     * @param value The VPN connection Cloud Router name.
     */
    @JvmName("aclyisyewpjonbwm")
    public suspend fun router(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.router = mapped
    }

    /**
     * @param value The network ID of VPC to connect to.
     */
    @JvmName("fewfflejswfckkju")
    public suspend fun vpc(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.vpc = mapped
    }

    /**
     * @param value Project detail of the VPC network. Required if VPC is in a different project than the cluster project.
     * Structure is documented below.
     */
    @JvmName("qypvadrqocnxckqo")
    public suspend fun vpcProject(`value`: VpnConnectionVpcProjectArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.vpcProject = mapped
    }

    /**
     * @param argument Project detail of the VPC network. Required if VPC is in a different project than the cluster project.
     * Structure is documented below.
     */
    @JvmName("egvqyuralfaryomx")
    public suspend fun vpcProject(argument: suspend VpnConnectionVpcProjectArgsBuilder.() -> Unit) {
        val toBeMapped = VpnConnectionVpcProjectArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.vpcProject = mapped
    }

    internal fun build(): VpnConnectionArgs = VpnConnectionArgs(
        cluster = cluster,
        enableHighAvailability = enableHighAvailability,
        labels = labels,
        location = location,
        name = name,
        natGatewayIp = natGatewayIp,
        project = project,
        router = router,
        vpc = vpc,
        vpcProject = vpcProject,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy