com.pulumi.awsnative.mediapackagev2.kotlin.inputs.OriginEndpointEncryptionArgs.kt Maven / Gradle / Ivy
Show all versions of pulumi-aws-native-kotlin Show documentation
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.awsnative.mediapackagev2.kotlin.inputs
import com.pulumi.awsnative.mediapackagev2.inputs.OriginEndpointEncryptionArgs.builder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiNullFieldException
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName
/**
* The parameters for encrypting content.
* @property constantInitializationVector A 128-bit, 16-byte hex value represented by a 32-character string, used in conjunction with the key for encrypting content. If you don't specify a value, then MediaPackage creates the constant initialization vector (IV).
* @property encryptionMethod The encryption method to use.
* @property keyRotationIntervalSeconds The frequency (in seconds) of key changes for live workflows, in which content is streamed real time. The service retrieves content keys before the live content begins streaming, and then retrieves them as needed over the lifetime of the workflow. By default, key rotation is set to 300 seconds (5 minutes), the minimum rotation interval, which is equivalent to setting it to 300. If you don't enter an interval, content keys aren't rotated.
* The following example setting causes the service to rotate keys every thirty minutes: 1800
*
* @property spekeKeyProvider The SPEKE key provider to use for encryption.
*/
public data class OriginEndpointEncryptionArgs(
public val constantInitializationVector: Output? = null,
public val encryptionMethod: Output,
public val keyRotationIntervalSeconds: Output? = null,
public val spekeKeyProvider: Output,
) : ConvertibleToJava {
override fun toJava(): com.pulumi.awsnative.mediapackagev2.inputs.OriginEndpointEncryptionArgs =
com.pulumi.awsnative.mediapackagev2.inputs.OriginEndpointEncryptionArgs.builder()
.constantInitializationVector(constantInitializationVector?.applyValue({ args0 -> args0 }))
.encryptionMethod(encryptionMethod.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.keyRotationIntervalSeconds(keyRotationIntervalSeconds?.applyValue({ args0 -> args0 }))
.spekeKeyProvider(
spekeKeyProvider.applyValue({ args0 ->
args0.let({ args0 ->
args0.toJava()
})
}),
).build()
}
/**
* Builder for [OriginEndpointEncryptionArgs].
*/
@PulumiTagMarker
public class OriginEndpointEncryptionArgsBuilder internal constructor() {
private var constantInitializationVector: Output? = null
private var encryptionMethod: Output? = null
private var keyRotationIntervalSeconds: Output? = null
private var spekeKeyProvider: Output? = null
/**
* @param value A 128-bit, 16-byte hex value represented by a 32-character string, used in conjunction with the key for encrypting content. If you don't specify a value, then MediaPackage creates the constant initialization vector (IV).
*/
@JvmName("elnxgycdcavvxjuy")
public suspend fun constantInitializationVector(`value`: Output) {
this.constantInitializationVector = value
}
/**
* @param value The encryption method to use.
*/
@JvmName("yibcdxrxcfeydwoy")
public suspend fun encryptionMethod(`value`: Output) {
this.encryptionMethod = value
}
/**
* @param value The frequency (in seconds) of key changes for live workflows, in which content is streamed real time. The service retrieves content keys before the live content begins streaming, and then retrieves them as needed over the lifetime of the workflow. By default, key rotation is set to 300 seconds (5 minutes), the minimum rotation interval, which is equivalent to setting it to 300. If you don't enter an interval, content keys aren't rotated.
* The following example setting causes the service to rotate keys every thirty minutes: 1800
*
*/
@JvmName("cflnmnstiylqdvps")
public suspend fun keyRotationIntervalSeconds(`value`: Output) {
this.keyRotationIntervalSeconds = value
}
/**
* @param value The SPEKE key provider to use for encryption.
*/
@JvmName("jswagvqwqmncbddg")
public suspend fun spekeKeyProvider(`value`: Output) {
this.spekeKeyProvider = value
}
/**
* @param value A 128-bit, 16-byte hex value represented by a 32-character string, used in conjunction with the key for encrypting content. If you don't specify a value, then MediaPackage creates the constant initialization vector (IV).
*/
@JvmName("lftochvwttklohpl")
public suspend fun constantInitializationVector(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.constantInitializationVector = mapped
}
/**
* @param value The encryption method to use.
*/
@JvmName("xrowemmuolhhbrjx")
public suspend fun encryptionMethod(`value`: OriginEndpointEncryptionMethodArgs) {
val toBeMapped = value
val mapped = toBeMapped.let({ args0 -> of(args0) })
this.encryptionMethod = mapped
}
/**
* @param argument The encryption method to use.
*/
@JvmName("fswkfcpthasjoqvx")
public suspend fun encryptionMethod(argument: suspend OriginEndpointEncryptionMethodArgsBuilder.() -> Unit) {
val toBeMapped = OriginEndpointEncryptionMethodArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.encryptionMethod = mapped
}
/**
* @param value The frequency (in seconds) of key changes for live workflows, in which content is streamed real time. The service retrieves content keys before the live content begins streaming, and then retrieves them as needed over the lifetime of the workflow. By default, key rotation is set to 300 seconds (5 minutes), the minimum rotation interval, which is equivalent to setting it to 300. If you don't enter an interval, content keys aren't rotated.
* The following example setting causes the service to rotate keys every thirty minutes: 1800
*
*/
@JvmName("nwleqhronuqtafod")
public suspend fun keyRotationIntervalSeconds(`value`: Int?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.keyRotationIntervalSeconds = mapped
}
/**
* @param value The SPEKE key provider to use for encryption.
*/
@JvmName("euvkrvtxyojpgiby")
public suspend fun spekeKeyProvider(`value`: OriginEndpointSpekeKeyProviderArgs) {
val toBeMapped = value
val mapped = toBeMapped.let({ args0 -> of(args0) })
this.spekeKeyProvider = mapped
}
/**
* @param argument The SPEKE key provider to use for encryption.
*/
@JvmName("oosfqhvvcybxcyjn")
public suspend fun spekeKeyProvider(argument: suspend OriginEndpointSpekeKeyProviderArgsBuilder.() -> Unit) {
val toBeMapped = OriginEndpointSpekeKeyProviderArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.spekeKeyProvider = mapped
}
internal fun build(): OriginEndpointEncryptionArgs = OriginEndpointEncryptionArgs(
constantInitializationVector = constantInitializationVector,
encryptionMethod = encryptionMethod ?: throw PulumiNullFieldException("encryptionMethod"),
keyRotationIntervalSeconds = keyRotationIntervalSeconds,
spekeKeyProvider = spekeKeyProvider ?: throw PulumiNullFieldException("spekeKeyProvider"),
)
}