com.pulumi.gcp.clouddomains.kotlin.inputs.RegistrationContactSettingsAdminContactPostalAddressArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-gcp-kotlin Show documentation
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.clouddomains.kotlin.inputs

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.clouddomains.inputs.RegistrationContactSettingsAdminContactPostalAddressArgs.builder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiNullFieldException
import com.pulumi.kotlin.PulumiTagMarker
import kotlin.String
import kotlin.Suppress
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 *
 * @property addressLines Unstructured address lines describing the lower levels of an address.
 * Because values in addressLines do not have type information and may sometimes contain multiple values in a single
 * field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
 * "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
 * is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
 * the most specific line of an address can be selected based on the language.
 * @property administrativeArea Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state,
 * a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community
 * (e.g. "Barcelona" and not "Catalonia"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland
 * this should be left unpopulated.
 * @property locality Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world
 * where localities are not well defined or do not fit into this structure well, leave locality empty and use addressLines.
 * @property organization The name of the organization at the address.
 * @property postalCode Postal code of the address. Not all countries use or require postal codes to be present, but where they are used,
 * they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).
 * @property recipients The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
 * it might contain "care of" information.
 * - - -
 * @property regionCode Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to
 * ensure the value is correct. See https://cldr.unicode.org/ and
 * https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.
 */
public data class RegistrationContactSettingsAdminContactPostalAddressArgs(
    public val addressLines: Output>? = null,
    public val administrativeArea: Output? = null,
    public val locality: Output? = null,
    public val organization: Output? = null,
    public val postalCode: Output? = null,
    public val recipients: Output>? = null,
    public val regionCode: Output,
) :
    ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.clouddomains.inputs.RegistrationContactSettingsAdminContactPostalAddressArgs =
        com.pulumi.gcp.clouddomains.inputs.RegistrationContactSettingsAdminContactPostalAddressArgs.builder()
            .addressLines(addressLines?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .administrativeArea(administrativeArea?.applyValue({ args0 -> args0 }))
            .locality(locality?.applyValue({ args0 -> args0 }))
            .organization(organization?.applyValue({ args0 -> args0 }))
            .postalCode(postalCode?.applyValue({ args0 -> args0 }))
            .recipients(recipients?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .regionCode(regionCode.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [RegistrationContactSettingsAdminContactPostalAddressArgs].
 */
@PulumiTagMarker
public class RegistrationContactSettingsAdminContactPostalAddressArgsBuilder internal constructor() {
    private var addressLines: Output>? = null

    private var administrativeArea: Output? = null

    private var locality: Output? = null

    private var organization: Output? = null

    private var postalCode: Output? = null

    private var recipients: Output>? = null

    private var regionCode: Output? = null

    /**
     * @param value Unstructured address lines describing the lower levels of an address.
     * Because values in addressLines do not have type information and may sometimes contain multiple values in a single
     * field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
     * "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
     * is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
     * the most specific line of an address can be selected based on the language.
     */
    @JvmName("eeqqbiojbeuayqpj")
    public suspend fun addressLines(`value`: Output>) {
        this.addressLines = value
    }

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

    /**
     * @param values Unstructured address lines describing the lower levels of an address.
     * Because values in addressLines do not have type information and may sometimes contain multiple values in a single
     * field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
     * "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
     * is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
     * the most specific line of an address can be selected based on the language.
     */
    @JvmName("ryqaiyyowbkjvxog")
    public suspend fun addressLines(values: List>) {
        this.addressLines = Output.all(values)
    }

    /**
     * @param value Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state,
     * a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community
     * (e.g. "Barcelona" and not "Catalonia"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland
     * this should be left unpopulated.
     */
    @JvmName("hlfrqvomfnfpdpou")
    public suspend fun administrativeArea(`value`: Output) {
        this.administrativeArea = value
    }

    /**
     * @param value Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world
     * where localities are not well defined or do not fit into this structure well, leave locality empty and use addressLines.
     */
    @JvmName("awpmtsumuwoeslcm")
    public suspend fun locality(`value`: Output) {
        this.locality = value
    }

    /**
     * @param value The name of the organization at the address.
     */
    @JvmName("sglwypjysaxrpxuu")
    public suspend fun organization(`value`: Output) {
        this.organization = value
    }

    /**
     * @param value Postal code of the address. Not all countries use or require postal codes to be present, but where they are used,
     * they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).
     */
    @JvmName("dndyywacjnajnjfo")
    public suspend fun postalCode(`value`: Output) {
        this.postalCode = value
    }

    /**
     * @param value The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
     * it might contain "care of" information.
     * - - -
     */
    @JvmName("cncfmbylahsdoaah")
    public suspend fun recipients(`value`: Output>) {
        this.recipients = value
    }

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

    /**
     * @param values The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
     * it might contain "care of" information.
     * - - -
     */
    @JvmName("gllppuawygfrrtpk")
    public suspend fun recipients(values: List>) {
        this.recipients = Output.all(values)
    }

    /**
     * @param value Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to
     * ensure the value is correct. See https://cldr.unicode.org/ and
     * https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.
     */
    @JvmName("atekjcpesbhfgqsy")
    public suspend fun regionCode(`value`: Output) {
        this.regionCode = value
    }

    /**
     * @param value Unstructured address lines describing the lower levels of an address.
     * Because values in addressLines do not have type information and may sometimes contain multiple values in a single
     * field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
     * "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
     * is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
     * the most specific line of an address can be selected based on the language.
     */
    @JvmName("qqwrnwwapdjbtgoq")
    public suspend fun addressLines(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.addressLines = mapped
    }

    /**
     * @param values Unstructured address lines describing the lower levels of an address.
     * Because values in addressLines do not have type information and may sometimes contain multiple values in a single
     * field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
     * "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
     * is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
     * the most specific line of an address can be selected based on the language.
     */
    @JvmName("abjntbjwajmpvqsk")
    public suspend fun addressLines(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.addressLines = mapped
    }

    /**
     * @param value Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state,
     * a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community
     * (e.g. "Barcelona" and not "Catalonia"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland
     * this should be left unpopulated.
     */
    @JvmName("vlfvkxsdlrqhlaay")
    public suspend fun administrativeArea(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.administrativeArea = mapped
    }

    /**
     * @param value Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world
     * where localities are not well defined or do not fit into this structure well, leave locality empty and use addressLines.
     */
    @JvmName("ymobcoloyxkylslf")
    public suspend fun locality(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.locality = mapped
    }

    /**
     * @param value The name of the organization at the address.
     */
    @JvmName("opgltewwappmjawq")
    public suspend fun organization(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.organization = mapped
    }

    /**
     * @param value Postal code of the address. Not all countries use or require postal codes to be present, but where they are used,
     * they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).
     */
    @JvmName("mdfgrlfderdiflth")
    public suspend fun postalCode(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.postalCode = mapped
    }

    /**
     * @param value The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
     * it might contain "care of" information.
     * - - -
     */
    @JvmName("urrddgvddcgntody")
    public suspend fun recipients(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.recipients = mapped
    }

    /**
     * @param values The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
     * it might contain "care of" information.
     * - - -
     */
    @JvmName("vkcieulltigrarpt")
    public suspend fun recipients(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.recipients = mapped
    }

    /**
     * @param value Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to
     * ensure the value is correct. See https://cldr.unicode.org/ and
     * https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.
     */
    @JvmName("xcemebjnrmrrwqqj")
    public suspend fun regionCode(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.regionCode = mapped
    }

    internal fun build(): RegistrationContactSettingsAdminContactPostalAddressArgs =
        RegistrationContactSettingsAdminContactPostalAddressArgs(
            addressLines = addressLines,
            administrativeArea = administrativeArea,
            locality = locality,
            organization = organization,
            postalCode = postalCode,
            recipients = recipients,
            regionCode = regionCode ?: throw PulumiNullFieldException("regionCode"),
        )
}