com.pulumi.gcp.appengine.kotlin.inputs.FlexibleAppVersionHandlerStaticFilesArgs.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.appengine.kotlin.inputs

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionHandlerStaticFilesArgs.builder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import kotlin.Boolean
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 *
 * @property applicationReadable Whether files should also be uploaded as code data. By default, files declared in static file handlers are
 * uploaded as static data and are only served to end users; they cannot be read by the application. If enabled,
 * uploads are charged against both your code and static data storage resource quotas.
 * @property expiration Time a static file served by this handler should be cached by web proxies and browsers.
 * A duration in seconds with up to nine fractional digits, terminated by 's'. Example "3.5s".
 * Default is '0s'
 * @property httpHeaders HTTP headers to use for all responses from these URLs.
 * An object containing a list of "key:value" value pairs.".
 * @property mimeType MIME type used to serve all files served by this handler.
 * Defaults to file-specific MIME types, which are derived from each file's filename extension.
 * @property path Path to the static files matched by the URL pattern, from the application root directory.
 * The path can refer to text matched in groupings in the URL pattern.
 * @property requireMatchingFile Whether this handler should match the request if the file referenced by the handler does not exist.
 * @property uploadPathRegex Regular expression that matches the file paths for all files that should be referenced by this handler.
 */
public data class FlexibleAppVersionHandlerStaticFilesArgs(
    public val applicationReadable: Output? = null,
    public val expiration: Output? = null,
    public val httpHeaders: Output>? = null,
    public val mimeType: Output? = null,
    public val path: Output? = null,
    public val requireMatchingFile: Output? = null,
    public val uploadPathRegex: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.appengine.inputs.FlexibleAppVersionHandlerStaticFilesArgs =
        com.pulumi.gcp.appengine.inputs.FlexibleAppVersionHandlerStaticFilesArgs.builder()
            .applicationReadable(applicationReadable?.applyValue({ args0 -> args0 }))
            .expiration(expiration?.applyValue({ args0 -> args0 }))
            .httpHeaders(
                httpHeaders?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.key.to(args0.value)
                    }).toMap()
                }),
            )
            .mimeType(mimeType?.applyValue({ args0 -> args0 }))
            .path(path?.applyValue({ args0 -> args0 }))
            .requireMatchingFile(requireMatchingFile?.applyValue({ args0 -> args0 }))
            .uploadPathRegex(uploadPathRegex?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [FlexibleAppVersionHandlerStaticFilesArgs].
 */
@PulumiTagMarker
public class FlexibleAppVersionHandlerStaticFilesArgsBuilder internal constructor() {
    private var applicationReadable: Output? = null

    private var expiration: Output? = null

    private var httpHeaders: Output>? = null

    private var mimeType: Output? = null

    private var path: Output? = null

    private var requireMatchingFile: Output? = null

    private var uploadPathRegex: Output? = null

    /**
     * @param value Whether files should also be uploaded as code data. By default, files declared in static file handlers are
     * uploaded as static data and are only served to end users; they cannot be read by the application. If enabled,
     * uploads are charged against both your code and static data storage resource quotas.
     */
    @JvmName("juvjfewsqgqcenll")
    public suspend fun applicationReadable(`value`: Output) {
        this.applicationReadable = value
    }

    /**
     * @param value Time a static file served by this handler should be cached by web proxies and browsers.
     * A duration in seconds with up to nine fractional digits, terminated by 's'. Example "3.5s".
     * Default is '0s'
     */
    @JvmName("gcgkdcjdiacsstgf")
    public suspend fun expiration(`value`: Output) {
        this.expiration = value
    }

    /**
     * @param value HTTP headers to use for all responses from these URLs.
     * An object containing a list of "key:value" value pairs.".
     */
    @JvmName("howwcekkwllsqvuc")
    public suspend fun httpHeaders(`value`: Output>) {
        this.httpHeaders = value
    }

    /**
     * @param value MIME type used to serve all files served by this handler.
     * Defaults to file-specific MIME types, which are derived from each file's filename extension.
     */
    @JvmName("deyoymoxkmtdcmyp")
    public suspend fun mimeType(`value`: Output) {
        this.mimeType = value
    }

    /**
     * @param value Path to the static files matched by the URL pattern, from the application root directory.
     * The path can refer to text matched in groupings in the URL pattern.
     */
    @JvmName("parofumnfvxaftrq")
    public suspend fun path(`value`: Output) {
        this.path = value
    }

    /**
     * @param value Whether this handler should match the request if the file referenced by the handler does not exist.
     */
    @JvmName("ulgpxcagtdmrdcoh")
    public suspend fun requireMatchingFile(`value`: Output) {
        this.requireMatchingFile = value
    }

    /**
     * @param value Regular expression that matches the file paths for all files that should be referenced by this handler.
     */
    @JvmName("oeargccsbnekbsvm")
    public suspend fun uploadPathRegex(`value`: Output) {
        this.uploadPathRegex = value
    }

    /**
     * @param value Whether files should also be uploaded as code data. By default, files declared in static file handlers are
     * uploaded as static data and are only served to end users; they cannot be read by the application. If enabled,
     * uploads are charged against both your code and static data storage resource quotas.
     */
    @JvmName("pglvybhnefevkgot")
    public suspend fun applicationReadable(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.applicationReadable = mapped
    }

    /**
     * @param value Time a static file served by this handler should be cached by web proxies and browsers.
     * A duration in seconds with up to nine fractional digits, terminated by 's'. Example "3.5s".
     * Default is '0s'
     */
    @JvmName("enhokwbhlxvivvkc")
    public suspend fun expiration(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.expiration = mapped
    }

    /**
     * @param value HTTP headers to use for all responses from these URLs.
     * An object containing a list of "key:value" value pairs.".
     */
    @JvmName("bhxjbdagfghamtns")
    public suspend fun httpHeaders(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.httpHeaders = mapped
    }

    /**
     * @param values HTTP headers to use for all responses from these URLs.
     * An object containing a list of "key:value" value pairs.".
     */
    @JvmName("flxlgpemgbnalorg")
    public fun httpHeaders(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.httpHeaders = mapped
    }

    /**
     * @param value MIME type used to serve all files served by this handler.
     * Defaults to file-specific MIME types, which are derived from each file's filename extension.
     */
    @JvmName("ntmtjscpdlustvuu")
    public suspend fun mimeType(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.mimeType = mapped
    }

    /**
     * @param value Path to the static files matched by the URL pattern, from the application root directory.
     * The path can refer to text matched in groupings in the URL pattern.
     */
    @JvmName("hnrcqkdccvsouyse")
    public suspend fun path(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.path = mapped
    }

    /**
     * @param value Whether this handler should match the request if the file referenced by the handler does not exist.
     */
    @JvmName("wjxpqrysqgitakpn")
    public suspend fun requireMatchingFile(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.requireMatchingFile = mapped
    }

    /**
     * @param value Regular expression that matches the file paths for all files that should be referenced by this handler.
     */
    @JvmName("hvuuwcdmaqrfvhyo")
    public suspend fun uploadPathRegex(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.uploadPathRegex = mapped
    }

    internal fun build(): FlexibleAppVersionHandlerStaticFilesArgs =
        FlexibleAppVersionHandlerStaticFilesArgs(
            applicationReadable = applicationReadable,
            expiration = expiration,
            httpHeaders = httpHeaders,
            mimeType = mimeType,
            path = path,
            requireMatchingFile = requireMatchingFile,
            uploadPathRegex = uploadPathRegex,
        )
}