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

com.pulumi.azurenative.storagecache.kotlin.StorageTargetArgs.kt Maven / Gradle / Ivy

@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azurenative.storagecache.kotlin

import com.pulumi.azurenative.storagecache.StorageTargetArgs.builder
import com.pulumi.azurenative.storagecache.kotlin.enums.OperationalStateType
import com.pulumi.azurenative.storagecache.kotlin.enums.StorageTargetType
import com.pulumi.azurenative.storagecache.kotlin.inputs.BlobNfsTargetArgs
import com.pulumi.azurenative.storagecache.kotlin.inputs.BlobNfsTargetArgsBuilder
import com.pulumi.azurenative.storagecache.kotlin.inputs.ClfsTargetArgs
import com.pulumi.azurenative.storagecache.kotlin.inputs.ClfsTargetArgsBuilder
import com.pulumi.azurenative.storagecache.kotlin.inputs.NamespaceJunctionArgs
import com.pulumi.azurenative.storagecache.kotlin.inputs.NamespaceJunctionArgsBuilder
import com.pulumi.azurenative.storagecache.kotlin.inputs.Nfs3TargetArgs
import com.pulumi.azurenative.storagecache.kotlin.inputs.Nfs3TargetArgsBuilder
import com.pulumi.azurenative.storagecache.kotlin.inputs.UnknownTargetArgs
import com.pulumi.azurenative.storagecache.kotlin.inputs.UnknownTargetArgsBuilder
import com.pulumi.core.Either
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * Type of the Storage Target.
 * Azure REST API version: 2023-05-01. Prior API version in Azure Native 1.x: 2021-03-01.
 * Other available API versions: 2019-11-01, 2021-03-01, 2023-11-01-preview, 2024-03-01.
 * ## Example Usage
 * ### StorageTargets_CreateOrUpdate
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using AzureNative = Pulumi.AzureNative;
 * return await Deployment.RunAsync(() =>
 * {
 *     var storageTarget = new AzureNative.StorageCache.StorageTarget("storageTarget", new()
 *     {
 *         CacheName = "sc1",
 *         Junctions = new[]
 *         {
 *             new AzureNative.StorageCache.Inputs.NamespaceJunctionArgs
 *             {
 *                 NamespacePath = "/path/on/cache",
 *                 NfsAccessPolicy = "default",
 *                 NfsExport = "exp1",
 *                 TargetPath = "/path/on/exp1",
 *             },
 *             new AzureNative.StorageCache.Inputs.NamespaceJunctionArgs
 *             {
 *                 NamespacePath = "/path2/on/cache",
 *                 NfsAccessPolicy = "rootSquash",
 *                 NfsExport = "exp2",
 *                 TargetPath = "/path2/on/exp2",
 *             },
 *         },
 *         Nfs3 = new AzureNative.StorageCache.Inputs.Nfs3TargetArgs
 *         {
 *             Target = "10.0.44.44",
 *             UsageModel = "READ_ONLY",
 *             VerificationTimer = 30,
 *         },
 *         ResourceGroupName = "scgroup",
 *         StorageTargetName = "st1",
 *         TargetType = AzureNative.StorageCache.StorageTargetType.Nfs3,
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	storagecache "github.com/pulumi/pulumi-azure-native-sdk/storagecache/v2"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := storagecache.NewStorageTarget(ctx, "storageTarget", &storagecache.StorageTargetArgs{
 * 			CacheName: pulumi.String("sc1"),
 * 			Junctions: storagecache.NamespaceJunctionArray{
 * 				&storagecache.NamespaceJunctionArgs{
 * 					NamespacePath:   pulumi.String("/path/on/cache"),
 * 					NfsAccessPolicy: pulumi.String("default"),
 * 					NfsExport:       pulumi.String("exp1"),
 * 					TargetPath:      pulumi.String("/path/on/exp1"),
 * 				},
 * 				&storagecache.NamespaceJunctionArgs{
 * 					NamespacePath:   pulumi.String("/path2/on/cache"),
 * 					NfsAccessPolicy: pulumi.String("rootSquash"),
 * 					NfsExport:       pulumi.String("exp2"),
 * 					TargetPath:      pulumi.String("/path2/on/exp2"),
 * 				},
 * 			},
 * 			Nfs3: &storagecache.Nfs3TargetArgs{
 * 				Target:            pulumi.String("10.0.44.44"),
 * 				UsageModel:        pulumi.String("READ_ONLY"),
 * 				VerificationTimer: pulumi.Int(30),
 * 			},
 * 			ResourceGroupName: pulumi.String("scgroup"),
 * 			StorageTargetName: pulumi.String("st1"),
 * 			TargetType:        pulumi.String(storagecache.StorageTargetTypeNfs3),
 * 		})
 * 		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.azurenative.storagecache.StorageTarget;
 * import com.pulumi.azurenative.storagecache.StorageTargetArgs;
 * import com.pulumi.azurenative.storagecache.inputs.NamespaceJunctionArgs;
 * import com.pulumi.azurenative.storagecache.inputs.Nfs3TargetArgs;
 * 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 storageTarget = new StorageTarget("storageTarget", StorageTargetArgs.builder()
 *             .cacheName("sc1")
 *             .junctions(
 *                 NamespaceJunctionArgs.builder()
 *                     .namespacePath("/path/on/cache")
 *                     .nfsAccessPolicy("default")
 *                     .nfsExport("exp1")
 *                     .targetPath("/path/on/exp1")
 *                     .build(),
 *                 NamespaceJunctionArgs.builder()
 *                     .namespacePath("/path2/on/cache")
 *                     .nfsAccessPolicy("rootSquash")
 *                     .nfsExport("exp2")
 *                     .targetPath("/path2/on/exp2")
 *                     .build())
 *             .nfs3(Nfs3TargetArgs.builder()
 *                 .target("10.0.44.44")
 *                 .usageModel("READ_ONLY")
 *                 .verificationTimer(30)
 *                 .build())
 *             .resourceGroupName("scgroup")
 *             .storageTargetName("st1")
 *             .targetType("nfs3")
 *             .build());
 *     }
 * }
 * ```
 * ### StorageTargets_CreateOrUpdate_BlobNfs
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using AzureNative = Pulumi.AzureNative;
 * return await Deployment.RunAsync(() =>
 * {
 *     var storageTarget = new AzureNative.StorageCache.StorageTarget("storageTarget", new()
 *     {
 *         BlobNfs = new AzureNative.StorageCache.Inputs.BlobNfsTargetArgs
 *         {
 *             Target = "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/scgroup/providers/Microsoft.Storage/storageAccounts/blofnfs/blobServices/default/containers/blobnfs",
 *             UsageModel = "READ_WRITE",
 *             VerificationTimer = 28800,
 *             WriteBackTimer = 3600,
 *         },
 *         CacheName = "sc1",
 *         Junctions = new[]
 *         {
 *             new AzureNative.StorageCache.Inputs.NamespaceJunctionArgs
 *             {
 *                 NamespacePath = "/blobnfs",
 *             },
 *         },
 *         ResourceGroupName = "scgroup",
 *         StorageTargetName = "st1",
 *         TargetType = AzureNative.StorageCache.StorageTargetType.BlobNfs,
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	storagecache "github.com/pulumi/pulumi-azure-native-sdk/storagecache/v2"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := storagecache.NewStorageTarget(ctx, "storageTarget", &storagecache.StorageTargetArgs{
 * 			BlobNfs: &storagecache.BlobNfsTargetArgs{
 * 				Target:            pulumi.String("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/scgroup/providers/Microsoft.Storage/storageAccounts/blofnfs/blobServices/default/containers/blobnfs"),
 * 				UsageModel:        pulumi.String("READ_WRITE"),
 * 				VerificationTimer: pulumi.Int(28800),
 * 				WriteBackTimer:    pulumi.Int(3600),
 * 			},
 * 			CacheName: pulumi.String("sc1"),
 * 			Junctions: storagecache.NamespaceJunctionArray{
 * 				&storagecache.NamespaceJunctionArgs{
 * 					NamespacePath: pulumi.String("/blobnfs"),
 * 				},
 * 			},
 * 			ResourceGroupName: pulumi.String("scgroup"),
 * 			StorageTargetName: pulumi.String("st1"),
 * 			TargetType:        pulumi.String(storagecache.StorageTargetTypeBlobNfs),
 * 		})
 * 		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.azurenative.storagecache.StorageTarget;
 * import com.pulumi.azurenative.storagecache.StorageTargetArgs;
 * import com.pulumi.azurenative.storagecache.inputs.BlobNfsTargetArgs;
 * import com.pulumi.azurenative.storagecache.inputs.NamespaceJunctionArgs;
 * 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 storageTarget = new StorageTarget("storageTarget", StorageTargetArgs.builder()
 *             .blobNfs(BlobNfsTargetArgs.builder()
 *                 .target("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/scgroup/providers/Microsoft.Storage/storageAccounts/blofnfs/blobServices/default/containers/blobnfs")
 *                 .usageModel("READ_WRITE")
 *                 .verificationTimer(28800)
 *                 .writeBackTimer(3600)
 *                 .build())
 *             .cacheName("sc1")
 *             .junctions(NamespaceJunctionArgs.builder()
 *                 .namespacePath("/blobnfs")
 *                 .build())
 *             .resourceGroupName("scgroup")
 *             .storageTargetName("st1")
 *             .targetType("blobNfs")
 *             .build());
 *     }
 * }
 * ```
 * ### StorageTargets_CreateOrUpdate_NoJunctions
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using AzureNative = Pulumi.AzureNative;
 * return await Deployment.RunAsync(() =>
 * {
 *     var storageTarget = new AzureNative.StorageCache.StorageTarget("storageTarget", new()
 *     {
 *         CacheName = "sc1",
 *         Nfs3 = new AzureNative.StorageCache.Inputs.Nfs3TargetArgs
 *         {
 *             Target = "10.0.44.44",
 *             UsageModel = "READ_ONLY",
 *             VerificationTimer = 30,
 *         },
 *         ResourceGroupName = "scgroup",
 *         StorageTargetName = "st1",
 *         TargetType = AzureNative.StorageCache.StorageTargetType.Nfs3,
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	storagecache "github.com/pulumi/pulumi-azure-native-sdk/storagecache/v2"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := storagecache.NewStorageTarget(ctx, "storageTarget", &storagecache.StorageTargetArgs{
 * 			CacheName: pulumi.String("sc1"),
 * 			Nfs3: &storagecache.Nfs3TargetArgs{
 * 				Target:            pulumi.String("10.0.44.44"),
 * 				UsageModel:        pulumi.String("READ_ONLY"),
 * 				VerificationTimer: pulumi.Int(30),
 * 			},
 * 			ResourceGroupName: pulumi.String("scgroup"),
 * 			StorageTargetName: pulumi.String("st1"),
 * 			TargetType:        pulumi.String(storagecache.StorageTargetTypeNfs3),
 * 		})
 * 		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.azurenative.storagecache.StorageTarget;
 * import com.pulumi.azurenative.storagecache.StorageTargetArgs;
 * import com.pulumi.azurenative.storagecache.inputs.Nfs3TargetArgs;
 * 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 storageTarget = new StorageTarget("storageTarget", StorageTargetArgs.builder()
 *             .cacheName("sc1")
 *             .nfs3(Nfs3TargetArgs.builder()
 *                 .target("10.0.44.44")
 *                 .usageModel("READ_ONLY")
 *                 .verificationTimer(30)
 *                 .build())
 *             .resourceGroupName("scgroup")
 *             .storageTargetName("st1")
 *             .targetType("nfs3")
 *             .build());
 *     }
 * }
 * ```
 * ## Import
 * An existing resource can be imported using its type token, name, and identifier, e.g.
 * ```sh
 * $ pulumi import azure-native:storagecache:StorageTarget st1 /subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.StorageCache/caches/{cacheName}/storageTargets/{storageTargetName}
 * ```
 * @property blobNfs Properties when targetType is blobNfs.
 * @property cacheName Name of cache. Length of name must not be greater than 80 and chars must be from the [-0-9a-zA-Z_] char class.
 * @property clfs Properties when targetType is clfs.
 * @property junctions List of cache namespace junctions to target for namespace associations.
 * @property nfs3 Properties when targetType is nfs3.
 * @property resourceGroupName The name of the resource group. The name is case insensitive.
 * @property state Storage target operational state.
 * @property storageTargetName Name of Storage Target.
 * @property targetType Type of the Storage Target.
 * @property unknown Properties when targetType is unknown.
 */
public data class StorageTargetArgs(
    public val blobNfs: Output? = null,
    public val cacheName: Output? = null,
    public val clfs: Output? = null,
    public val junctions: Output>? = null,
    public val nfs3: Output? = null,
    public val resourceGroupName: Output? = null,
    public val state: Output>? = null,
    public val storageTargetName: Output? = null,
    public val targetType: Output>? = null,
    public val unknown: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.storagecache.StorageTargetArgs =
        com.pulumi.azurenative.storagecache.StorageTargetArgs.builder()
            .blobNfs(blobNfs?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .cacheName(cacheName?.applyValue({ args0 -> args0 }))
            .clfs(clfs?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .junctions(
                junctions?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .nfs3(nfs3?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .resourceGroupName(resourceGroupName?.applyValue({ args0 -> args0 }))
            .state(
                state?.applyValue({ args0 ->
                    args0.transform({ args0 -> args0 }, { args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .storageTargetName(storageTargetName?.applyValue({ args0 -> args0 }))
            .targetType(
                targetType?.applyValue({ args0 ->
                    args0.transform({ args0 -> args0 }, { args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            )
            .unknown(unknown?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) })).build()
}

/**
 * Builder for [StorageTargetArgs].
 */
@PulumiTagMarker
public class StorageTargetArgsBuilder internal constructor() {
    private var blobNfs: Output? = null

    private var cacheName: Output? = null

    private var clfs: Output? = null

    private var junctions: Output>? = null

    private var nfs3: Output? = null

    private var resourceGroupName: Output? = null

    private var state: Output>? = null

    private var storageTargetName: Output? = null

    private var targetType: Output>? = null

    private var unknown: Output? = null

    /**
     * @param value Properties when targetType is blobNfs.
     */
    @JvmName("snsncbanepaguihr")
    public suspend fun blobNfs(`value`: Output) {
        this.blobNfs = value
    }

    /**
     * @param value Name of cache. Length of name must not be greater than 80 and chars must be from the [-0-9a-zA-Z_] char class.
     */
    @JvmName("avqrykwtdfxuccog")
    public suspend fun cacheName(`value`: Output) {
        this.cacheName = value
    }

    /**
     * @param value Properties when targetType is clfs.
     */
    @JvmName("brgrsxfuyfhmhcnh")
    public suspend fun clfs(`value`: Output) {
        this.clfs = value
    }

    /**
     * @param value List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("ldjyuhnklmjdpkad")
    public suspend fun junctions(`value`: Output>) {
        this.junctions = value
    }

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

    /**
     * @param values List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("jdvjcjbrshvxtpnp")
    public suspend fun junctions(values: List>) {
        this.junctions = Output.all(values)
    }

    /**
     * @param value Properties when targetType is nfs3.
     */
    @JvmName("jntagropvrxgbspw")
    public suspend fun nfs3(`value`: Output) {
        this.nfs3 = value
    }

    /**
     * @param value The name of the resource group. The name is case insensitive.
     */
    @JvmName("qiagulvyqrhkxpuk")
    public suspend fun resourceGroupName(`value`: Output) {
        this.resourceGroupName = value
    }

    /**
     * @param value Storage target operational state.
     */
    @JvmName("jxndbnngafpdgkoa")
    public suspend fun state(`value`: Output>) {
        this.state = value
    }

    /**
     * @param value Name of Storage Target.
     */
    @JvmName("gsifrfvraxyqvutm")
    public suspend fun storageTargetName(`value`: Output) {
        this.storageTargetName = value
    }

    /**
     * @param value Type of the Storage Target.
     */
    @JvmName("ajougesiumaigoso")
    public suspend fun targetType(`value`: Output>) {
        this.targetType = value
    }

    /**
     * @param value Properties when targetType is unknown.
     */
    @JvmName("cjabvcumkcuqhpxp")
    public suspend fun unknown(`value`: Output) {
        this.unknown = value
    }

    /**
     * @param value Properties when targetType is blobNfs.
     */
    @JvmName("bttwsusqmlhnmkhe")
    public suspend fun blobNfs(`value`: BlobNfsTargetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.blobNfs = mapped
    }

    /**
     * @param argument Properties when targetType is blobNfs.
     */
    @JvmName("yqqlhuxtawqojbch")
    public suspend fun blobNfs(argument: suspend BlobNfsTargetArgsBuilder.() -> Unit) {
        val toBeMapped = BlobNfsTargetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.blobNfs = mapped
    }

    /**
     * @param value Name of cache. Length of name must not be greater than 80 and chars must be from the [-0-9a-zA-Z_] char class.
     */
    @JvmName("ukstvkpadmpifwoc")
    public suspend fun cacheName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.cacheName = mapped
    }

    /**
     * @param value Properties when targetType is clfs.
     */
    @JvmName("yurafguvcqkpcnde")
    public suspend fun clfs(`value`: ClfsTargetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.clfs = mapped
    }

    /**
     * @param argument Properties when targetType is clfs.
     */
    @JvmName("uxcrbqhbvuubevea")
    public suspend fun clfs(argument: suspend ClfsTargetArgsBuilder.() -> Unit) {
        val toBeMapped = ClfsTargetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.clfs = mapped
    }

    /**
     * @param value List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("oedphbelgnrndnxb")
    public suspend fun junctions(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.junctions = mapped
    }

    /**
     * @param argument List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("iyxcgxqcwrbmhrvg")
    public suspend fun junctions(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            NamespaceJunctionArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.junctions = mapped
    }

    /**
     * @param argument List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("gjwchwvnxlgybfiv")
    public suspend fun junctions(vararg argument: suspend NamespaceJunctionArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            NamespaceJunctionArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.junctions = mapped
    }

    /**
     * @param argument List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("kshabtvflrjtvohn")
    public suspend fun junctions(argument: suspend NamespaceJunctionArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(NamespaceJunctionArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.junctions = mapped
    }

    /**
     * @param values List of cache namespace junctions to target for namespace associations.
     */
    @JvmName("vsxarrmuuhtrodws")
    public suspend fun junctions(vararg values: NamespaceJunctionArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.junctions = mapped
    }

    /**
     * @param value Properties when targetType is nfs3.
     */
    @JvmName("uygxboqpvbothxcc")
    public suspend fun nfs3(`value`: Nfs3TargetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.nfs3 = mapped
    }

    /**
     * @param argument Properties when targetType is nfs3.
     */
    @JvmName("fjdxkinvsjwemqlw")
    public suspend fun nfs3(argument: suspend Nfs3TargetArgsBuilder.() -> Unit) {
        val toBeMapped = Nfs3TargetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.nfs3 = mapped
    }

    /**
     * @param value The name of the resource group. The name is case insensitive.
     */
    @JvmName("ftbxjgcewjvwerea")
    public suspend fun resourceGroupName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.resourceGroupName = mapped
    }

    /**
     * @param value Storage target operational state.
     */
    @JvmName("nwqaviwmklpxamec")
    public suspend fun state(`value`: Either?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.state = mapped
    }

    /**
     * @param value Storage target operational state.
     */
    @JvmName("imidkfuegdawjfhj")
    public fun state(`value`: String) {
        val toBeMapped = Either.ofLeft(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.state = mapped
    }

    /**
     * @param value Storage target operational state.
     */
    @JvmName("xijcrasmolmntktx")
    public fun state(`value`: OperationalStateType) {
        val toBeMapped = Either.ofRight(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.state = mapped
    }

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

    /**
     * @param value Type of the Storage Target.
     */
    @JvmName("ixeydrwpwtxypmty")
    public suspend fun targetType(`value`: Either?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.targetType = mapped
    }

    /**
     * @param value Type of the Storage Target.
     */
    @JvmName("kxrohevlchievhuj")
    public fun targetType(`value`: String) {
        val toBeMapped = Either.ofLeft(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.targetType = mapped
    }

    /**
     * @param value Type of the Storage Target.
     */
    @JvmName("tiffvlnoxujlhytf")
    public fun targetType(`value`: StorageTargetType) {
        val toBeMapped = Either.ofRight(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.targetType = mapped
    }

    /**
     * @param value Properties when targetType is unknown.
     */
    @JvmName("pehbflqtrwvhegwq")
    public suspend fun unknown(`value`: UnknownTargetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.unknown = mapped
    }

    /**
     * @param argument Properties when targetType is unknown.
     */
    @JvmName("iaevghhtfdybrlys")
    public suspend fun unknown(argument: suspend UnknownTargetArgsBuilder.() -> Unit) {
        val toBeMapped = UnknownTargetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.unknown = mapped
    }

    internal fun build(): StorageTargetArgs = StorageTargetArgs(
        blobNfs = blobNfs,
        cacheName = cacheName,
        clfs = clfs,
        junctions = junctions,
        nfs3 = nfs3,
        resourceGroupName = resourceGroupName,
        state = state,
        storageTargetName = storageTargetName,
        targetType = targetType,
        unknown = unknown,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy