# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'AppDapr',
    'AppIdentity',
    'AppIngress',
    'AppIngressCustomDomain',
    'AppIngressTrafficWeight',
    'AppRegistry',
    'AppSecret',
    'AppTemplate',
    'AppTemplateContainer',
    'AppTemplateContainerEnv',
    'AppTemplateContainerLivenessProbe',
    'AppTemplateContainerLivenessProbeHeader',
    'AppTemplateContainerReadinessProbe',
    'AppTemplateContainerReadinessProbeHeader',
    'AppTemplateContainerStartupProbe',
    'AppTemplateContainerStartupProbeHeader',
    'AppTemplateContainerVolumeMount',
    'AppTemplateVolume',
    'EnvironmentDaprComponentMetadata',
    'EnvironmentDaprComponentSecret',
]

@pulumi.output_type
class AppDapr(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appId":
            suggest = "app_id"
        elif key == "appPort":
            suggest = "app_port"
        elif key == "appProtocol":
            suggest = "app_protocol"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppDapr. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppDapr.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppDapr.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 app_id: str,
                 app_port: int,
                 app_protocol: Optional[str] = None):
        """
        :param str app_id: The Dapr Application Identifier.
        :param int app_port: The port which the application is listening on. This is the same as the `ingress` port.
        :param str app_protocol: The protocol for the app. Possible values include `http` and `grpc`. Defaults to `http`.
        """
        pulumi.set(__self__, "app_id", app_id)
        pulumi.set(__self__, "app_port", app_port)
        if app_protocol is not None:
            pulumi.set(__self__, "app_protocol", app_protocol)

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> str:
        """
        The Dapr Application Identifier.
        """
        return pulumi.get(self, "app_id")

    @property
    @pulumi.getter(name="appPort")
    def app_port(self) -> int:
        """
        The port which the application is listening on. This is the same as the `ingress` port.
        """
        return pulumi.get(self, "app_port")

    @property
    @pulumi.getter(name="appProtocol")
    def app_protocol(self) -> Optional[str]:
        """
        The protocol for the app. Possible values include `http` and `grpc`. Defaults to `http`.
        """
        return pulumi.get(self, "app_protocol")


@pulumi.output_type
class AppIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: The type of managed identity to assign. Possible values are `UserAssigned` and `SystemAssigned`
        :param Sequence[str] identity_ids: A list of one or more Resource IDs for User Assigned Managed identities to assign. Required when `type` is set to `UserAssigned`.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of managed identity to assign. Possible values are `UserAssigned` and `SystemAssigned`
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        A list of one or more Resource IDs for User Assigned Managed identities to assign. Required when `type` is set to `UserAssigned`.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[str]:
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class AppIngress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetPort":
            suggest = "target_port"
        elif key == "trafficWeights":
            suggest = "traffic_weights"
        elif key == "allowInsecureConnections":
            suggest = "allow_insecure_connections"
        elif key == "customDomain":
            suggest = "custom_domain"
        elif key == "externalEnabled":
            suggest = "external_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppIngress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppIngress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppIngress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target_port: int,
                 traffic_weights: Sequence['outputs.AppIngressTrafficWeight'],
                 allow_insecure_connections: Optional[bool] = None,
                 custom_domain: Optional['outputs.AppIngressCustomDomain'] = None,
                 external_enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None,
                 transport: Optional[str] = None):
        """
        :param int target_port: The target port on the container for the Ingress traffic.
        :param Sequence['AppIngressTrafficWeightArgs'] traffic_weights: A `traffic_weight` block as detailed below.
        :param bool allow_insecure_connections: Should this ingress allow insecure connections?
        :param 'AppIngressCustomDomainArgs' custom_domain: One or more `custom_domain` block as detailed below.
        :param bool external_enabled: Is this an external Ingress.
        :param str fqdn: The FQDN of the ingress.
        :param str transport: The transport method for the Ingress. Possible values include `auto`, `http`, and `http2`. Defaults to `auto`
        """
        pulumi.set(__self__, "target_port", target_port)
        pulumi.set(__self__, "traffic_weights", traffic_weights)
        if allow_insecure_connections is not None:
            pulumi.set(__self__, "allow_insecure_connections", allow_insecure_connections)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if external_enabled is not None:
            pulumi.set(__self__, "external_enabled", external_enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)
        if transport is not None:
            pulumi.set(__self__, "transport", transport)

    @property
    @pulumi.getter(name="targetPort")
    def target_port(self) -> int:
        """
        The target port on the container for the Ingress traffic.
        """
        return pulumi.get(self, "target_port")

    @property
    @pulumi.getter(name="trafficWeights")
    def traffic_weights(self) -> Sequence['outputs.AppIngressTrafficWeight']:
        """
        A `traffic_weight` block as detailed below.
        """
        return pulumi.get(self, "traffic_weights")

    @property
    @pulumi.getter(name="allowInsecureConnections")
    def allow_insecure_connections(self) -> Optional[bool]:
        """
        Should this ingress allow insecure connections?
        """
        return pulumi.get(self, "allow_insecure_connections")

    @property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional['outputs.AppIngressCustomDomain']:
        """
        One or more `custom_domain` block as detailed below.
        """
        return pulumi.get(self, "custom_domain")

    @property
    @pulumi.getter(name="externalEnabled")
    def external_enabled(self) -> Optional[bool]:
        """
        Is this an external Ingress.
        """
        return pulumi.get(self, "external_enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        """
        The FQDN of the ingress.
        """
        return pulumi.get(self, "fqdn")

    @property
    @pulumi.getter
    def transport(self) -> Optional[str]:
        """
        The transport method for the Ingress. Possible values include `auto`, `http`, and `http2`. Defaults to `auto`
        """
        return pulumi.get(self, "transport")


@pulumi.output_type
class AppIngressCustomDomain(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateId":
            suggest = "certificate_id"
        elif key == "certificateBindingType":
            suggest = "certificate_binding_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppIngressCustomDomain. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppIngressCustomDomain.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppIngressCustomDomain.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 certificate_id: str,
                 name: str,
                 certificate_binding_type: Optional[str] = None):
        """
        :param str name: The name for this Container App. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "certificate_id", certificate_id)
        pulumi.set(__self__, "name", name)
        if certificate_binding_type is not None:
            pulumi.set(__self__, "certificate_binding_type", certificate_binding_type)

    @property
    @pulumi.getter(name="certificateId")
    def certificate_id(self) -> str:
        return pulumi.get(self, "certificate_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name for this Container App. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="certificateBindingType")
    def certificate_binding_type(self) -> Optional[str]:
        return pulumi.get(self, "certificate_binding_type")


@pulumi.output_type
class AppIngressTrafficWeight(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "latestRevision":
            suggest = "latest_revision"
        elif key == "revisionSuffix":
            suggest = "revision_suffix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppIngressTrafficWeight. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppIngressTrafficWeight.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppIngressTrafficWeight.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 percentage: int,
                 label: Optional[str] = None,
                 latest_revision: Optional[bool] = None,
                 revision_suffix: Optional[str] = None):
        """
        :param int percentage: The percentage of traffic which should be sent this revision.
        :param str label: The label to apply to the revision as a name prefix for routing traffic.
        :param bool latest_revision: This traffic Weight relates to the latest stable Container Revision.
        :param str revision_suffix: The suffix string to which this `traffic_weight` applies.
        """
        pulumi.set(__self__, "percentage", percentage)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if latest_revision is not None:
            pulumi.set(__self__, "latest_revision", latest_revision)
        if revision_suffix is not None:
            pulumi.set(__self__, "revision_suffix", revision_suffix)

    @property
    @pulumi.getter
    def percentage(self) -> int:
        """
        The percentage of traffic which should be sent this revision.
        """
        return pulumi.get(self, "percentage")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        The label to apply to the revision as a name prefix for routing traffic.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter(name="latestRevision")
    def latest_revision(self) -> Optional[bool]:
        """
        This traffic Weight relates to the latest stable Container Revision.
        """
        return pulumi.get(self, "latest_revision")

    @property
    @pulumi.getter(name="revisionSuffix")
    def revision_suffix(self) -> Optional[str]:
        """
        The suffix string to which this `traffic_weight` applies.
        """
        return pulumi.get(self, "revision_suffix")


@pulumi.output_type
class AppRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "passwordSecretName":
            suggest = "password_secret_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppRegistry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppRegistry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppRegistry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 server: str,
                 identity: Optional[str] = None,
                 password_secret_name: Optional[str] = None,
                 username: Optional[str] = None):
        """
        :param str server: The hostname for the Container Registry.
        :param str identity: Resource ID for the User Assigned Managed identity to use when pulling from the Container Registry.
        :param str password_secret_name: The name of the Secret Reference containing the password value for this user on the Container Registry, `username` must also be supplied.
        :param str username: The username to use for this Container Registry, `password_secret_name` must also be supplied..
        """
        pulumi.set(__self__, "server", server)
        if identity is not None:
            pulumi.set(__self__, "identity", identity)
        if password_secret_name is not None:
            pulumi.set(__self__, "password_secret_name", password_secret_name)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The hostname for the Container Registry.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def identity(self) -> Optional[str]:
        """
        Resource ID for the User Assigned Managed identity to use when pulling from the Container Registry.
        """
        return pulumi.get(self, "identity")

    @property
    @pulumi.getter(name="passwordSecretName")
    def password_secret_name(self) -> Optional[str]:
        """
        The name of the Secret Reference containing the password value for this user on the Container Registry, `username` must also be supplied.
        """
        return pulumi.get(self, "password_secret_name")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        The username to use for this Container Registry, `password_secret_name` must also be supplied..
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class AppSecret(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The Secret name.
        :param str value: The value for this secret.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Secret name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value for this secret.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class AppTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxReplicas":
            suggest = "max_replicas"
        elif key == "minReplicas":
            suggest = "min_replicas"
        elif key == "revisionSuffix":
            suggest = "revision_suffix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 containers: Sequence['outputs.AppTemplateContainer'],
                 max_replicas: Optional[int] = None,
                 min_replicas: Optional[int] = None,
                 revision_suffix: Optional[str] = None,
                 volumes: Optional[Sequence['outputs.AppTemplateVolume']] = None):
        """
        :param Sequence['AppTemplateContainerArgs'] containers: One or more `container` blocks as detailed below.
        :param int max_replicas: The maximum number of replicas for this container.
        :param int min_replicas: The minimum number of replicas for this container.
        :param str revision_suffix: The suffix for the revision. This value must be unique for the lifetime of the Resource. If omitted the service will use a hash function to create one.
        :param Sequence['AppTemplateVolumeArgs'] volumes: A `volume` block as detailed below.
        """
        pulumi.set(__self__, "containers", containers)
        if max_replicas is not None:
            pulumi.set(__self__, "max_replicas", max_replicas)
        if min_replicas is not None:
            pulumi.set(__self__, "min_replicas", min_replicas)
        if revision_suffix is not None:
            pulumi.set(__self__, "revision_suffix", revision_suffix)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)

    @property
    @pulumi.getter
    def containers(self) -> Sequence['outputs.AppTemplateContainer']:
        """
        One or more `container` blocks as detailed below.
        """
        return pulumi.get(self, "containers")

    @property
    @pulumi.getter(name="maxReplicas")
    def max_replicas(self) -> Optional[int]:
        """
        The maximum number of replicas for this container.
        """
        return pulumi.get(self, "max_replicas")

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> Optional[int]:
        """
        The minimum number of replicas for this container.
        """
        return pulumi.get(self, "min_replicas")

    @property
    @pulumi.getter(name="revisionSuffix")
    def revision_suffix(self) -> Optional[str]:
        """
        The suffix for the revision. This value must be unique for the lifetime of the Resource. If omitted the service will use a hash function to create one.
        """
        return pulumi.get(self, "revision_suffix")

    @property
    @pulumi.getter
    def volumes(self) -> Optional[Sequence['outputs.AppTemplateVolume']]:
        """
        A `volume` block as detailed below.
        """
        return pulumi.get(self, "volumes")


@pulumi.output_type
class AppTemplateContainer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ephemeralStorage":
            suggest = "ephemeral_storage"
        elif key == "livenessProbes":
            suggest = "liveness_probes"
        elif key == "readinessProbes":
            suggest = "readiness_probes"
        elif key == "startupProbes":
            suggest = "startup_probes"
        elif key == "volumeMounts":
            suggest = "volume_mounts"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplateContainer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplateContainer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplateContainer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpu: float,
                 image: str,
                 memory: str,
                 name: str,
                 args: Optional[Sequence[str]] = None,
                 commands: Optional[Sequence[str]] = None,
                 envs: Optional[Sequence['outputs.AppTemplateContainerEnv']] = None,
                 ephemeral_storage: Optional[str] = None,
                 liveness_probes: Optional[Sequence['outputs.AppTemplateContainerLivenessProbe']] = None,
                 readiness_probes: Optional[Sequence['outputs.AppTemplateContainerReadinessProbe']] = None,
                 startup_probes: Optional[Sequence['outputs.AppTemplateContainerStartupProbe']] = None,
                 volume_mounts: Optional[Sequence['outputs.AppTemplateContainerVolumeMount']] = None):
        """
        :param float cpu: The amount of vCPU to allocate to the container. Possible values include `0.25`, `0.5`, `0.75`, `1.0`, `1.25`, `1.5`, `1.75`, and `2.0`.
        :param str image: The image to use to create the container.
        :param str memory: The amount of memory to allocate to the container. Possible values include `0.5Gi`, `1.0Gi`, `1.5Gi`, `2.0Gi`, `2.5Gi`, `3.0Gi`, `3.5Gi`, and `4.0Gi`.
        :param str name: The name of the container
        :param Sequence[str] args: A list of extra arguments to pass to the container.
        :param Sequence[str] commands: A command to pass to the container to override the default. This is provided as a list of command line elements without spaces.
        :param Sequence['AppTemplateContainerEnvArgs'] envs: One or more `env` blocks as detailed below.
        :param str ephemeral_storage: The amount of ephemeral storage available to the Container App.
        :param Sequence['AppTemplateContainerLivenessProbeArgs'] liveness_probes: A `liveness_probe` block as detailed below.
        :param Sequence['AppTemplateContainerReadinessProbeArgs'] readiness_probes: A `readiness_probe` block as detailed below.
        :param Sequence['AppTemplateContainerStartupProbeArgs'] startup_probes: A `startup_probe` block as detailed below.
        :param Sequence['AppTemplateContainerVolumeMountArgs'] volume_mounts: A `volume_mounts` block as detailed below.
        """
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "memory", memory)
        pulumi.set(__self__, "name", name)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)
        if envs is not None:
            pulumi.set(__self__, "envs", envs)
        if ephemeral_storage is not None:
            pulumi.set(__self__, "ephemeral_storage", ephemeral_storage)
        if liveness_probes is not None:
            pulumi.set(__self__, "liveness_probes", liveness_probes)
        if readiness_probes is not None:
            pulumi.set(__self__, "readiness_probes", readiness_probes)
        if startup_probes is not None:
            pulumi.set(__self__, "startup_probes", startup_probes)
        if volume_mounts is not None:
            pulumi.set(__self__, "volume_mounts", volume_mounts)

    @property
    @pulumi.getter
    def cpu(self) -> float:
        """
        The amount of vCPU to allocate to the container. Possible values include `0.25`, `0.5`, `0.75`, `1.0`, `1.25`, `1.5`, `1.75`, and `2.0`.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def image(self) -> str:
        """
        The image to use to create the container.
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def memory(self) -> str:
        """
        The amount of memory to allocate to the container. Possible values include `0.5Gi`, `1.0Gi`, `1.5Gi`, `2.0Gi`, `2.5Gi`, `3.0Gi`, `3.5Gi`, and `4.0Gi`.
        """
        return pulumi.get(self, "memory")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the container
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def args(self) -> Optional[Sequence[str]]:
        """
        A list of extra arguments to pass to the container.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def commands(self) -> Optional[Sequence[str]]:
        """
        A command to pass to the container to override the default. This is provided as a list of command line elements without spaces.
        """
        return pulumi.get(self, "commands")

    @property
    @pulumi.getter
    def envs(self) -> Optional[Sequence['outputs.AppTemplateContainerEnv']]:
        """
        One or more `env` blocks as detailed below.
        """
        return pulumi.get(self, "envs")

    @property
    @pulumi.getter(name="ephemeralStorage")
    def ephemeral_storage(self) -> Optional[str]:
        """
        The amount of ephemeral storage available to the Container App.
        """
        return pulumi.get(self, "ephemeral_storage")

    @property
    @pulumi.getter(name="livenessProbes")
    def liveness_probes(self) -> Optional[Sequence['outputs.AppTemplateContainerLivenessProbe']]:
        """
        A `liveness_probe` block as detailed below.
        """
        return pulumi.get(self, "liveness_probes")

    @property
    @pulumi.getter(name="readinessProbes")
    def readiness_probes(self) -> Optional[Sequence['outputs.AppTemplateContainerReadinessProbe']]:
        """
        A `readiness_probe` block as detailed below.
        """
        return pulumi.get(self, "readiness_probes")

    @property
    @pulumi.getter(name="startupProbes")
    def startup_probes(self) -> Optional[Sequence['outputs.AppTemplateContainerStartupProbe']]:
        """
        A `startup_probe` block as detailed below.
        """
        return pulumi.get(self, "startup_probes")

    @property
    @pulumi.getter(name="volumeMounts")
    def volume_mounts(self) -> Optional[Sequence['outputs.AppTemplateContainerVolumeMount']]:
        """
        A `volume_mounts` block as detailed below.
        """
        return pulumi.get(self, "volume_mounts")


@pulumi.output_type
class AppTemplateContainerEnv(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplateContainerEnv. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplateContainerEnv.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplateContainerEnv.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 secret_name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str name: The name of the environment variable for the container.
        :param str secret_name: The name of the secret that contains the value for this environment variable.
        :param str value: The value for this environment variable.
        """
        pulumi.set(__self__, "name", name)
        if secret_name is not None:
            pulumi.set(__self__, "secret_name", secret_name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the environment variable for the container.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> Optional[str]:
        """
        The name of the secret that contains the value for this environment variable.
        """
        return pulumi.get(self, "secret_name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        The value for this environment variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class AppTemplateContainerLivenessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureCountThreshold":
            suggest = "failure_count_threshold"
        elif key == "initialDelay":
            suggest = "initial_delay"
        elif key == "intervalSeconds":
            suggest = "interval_seconds"
        elif key == "terminationGracePeriodSeconds":
            suggest = "termination_grace_period_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplateContainerLivenessProbe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplateContainerLivenessProbe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplateContainerLivenessProbe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: int,
                 transport: str,
                 failure_count_threshold: Optional[int] = None,
                 headers: Optional[Sequence['outputs.AppTemplateContainerLivenessProbeHeader']] = None,
                 host: Optional[str] = None,
                 initial_delay: Optional[int] = None,
                 interval_seconds: Optional[int] = None,
                 path: Optional[str] = None,
                 termination_grace_period_seconds: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param int port: The port number on which to connect. Possible values are between `1` and `65535`.
        :param str transport: Type of probe. Possible values are `TCP`, `HTTP`, and `HTTPS`.
        :param int failure_count_threshold: The number of consecutive failures required to consider this probe as failed. Possible values are between `1` and `10`. Defaults to `3`.
        :param Sequence['AppTemplateContainerLivenessProbeHeaderArgs'] headers: A `header` block as detailed below.
        :param str host: The probe hostname. Defaults to the pod IP address. Setting a value for `Host` in `headers` can be used to override this for `HTTP` and `HTTPS` type probes.
        :param int initial_delay: The time in seconds to wait after the container has started before the probe is started.
        :param int interval_seconds: (Optional) How often, in seconds, the probe should run. Possible values are in the range `1` - `240`. Defaults to `10`.
        :param str path: The URI to use with the `host` for http type probes. Not valid for `TCP` type probes. Defaults to `/`.
        :param int termination_grace_period_seconds: The time in seconds after the container is sent the termination signal before the process if forcibly killed.
        :param int timeout: Time in seconds after which the probe times out. Possible values are in the range `1` - `240`. Defaults to `1`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "transport", transport)
        if failure_count_threshold is not None:
            pulumi.set(__self__, "failure_count_threshold", failure_count_threshold)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if initial_delay is not None:
            pulumi.set(__self__, "initial_delay", initial_delay)
        if interval_seconds is not None:
            pulumi.set(__self__, "interval_seconds", interval_seconds)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if termination_grace_period_seconds is not None:
            pulumi.set(__self__, "termination_grace_period_seconds", termination_grace_period_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number on which to connect. Possible values are between `1` and `65535`.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def transport(self) -> str:
        """
        Type of probe. Possible values are `TCP`, `HTTP`, and `HTTPS`.
        """
        return pulumi.get(self, "transport")

    @property
    @pulumi.getter(name="failureCountThreshold")
    def failure_count_threshold(self) -> Optional[int]:
        """
        The number of consecutive failures required to consider this probe as failed. Possible values are between `1` and `10`. Defaults to `3`.
        """
        return pulumi.get(self, "failure_count_threshold")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Sequence['outputs.AppTemplateContainerLivenessProbeHeader']]:
        """
        A `header` block as detailed below.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        The probe hostname. Defaults to the pod IP address. Setting a value for `Host` in `headers` can be used to override this for `HTTP` and `HTTPS` type probes.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter(name="initialDelay")
    def initial_delay(self) -> Optional[int]:
        """
        The time in seconds to wait after the container has started before the probe is started.
        """
        return pulumi.get(self, "initial_delay")

    @property
    @pulumi.getter(name="intervalSeconds")
    def interval_seconds(self) -> Optional[int]:
        """
        (Optional) How often, in seconds, the probe should run. Possible values are in the range `1` - `240`. Defaults to `10`.
        """
        return pulumi.get(self, "interval_seconds")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The URI to use with the `host` for http type probes. Not valid for `TCP` type probes. Defaults to `/`.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="terminationGracePeriodSeconds")
    def termination_grace_period_seconds(self) -> Optional[int]:
        """
        The time in seconds after the container is sent the termination signal before the process if forcibly killed.
        """
        return pulumi.get(self, "termination_grace_period_seconds")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        """
        Time in seconds after which the probe times out. Possible values are in the range `1` - `240`. Defaults to `1`.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class AppTemplateContainerLivenessProbeHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The HTTP Header Name.
        :param str value: The HTTP Header value.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The HTTP Header Name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The HTTP Header value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class AppTemplateContainerReadinessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureCountThreshold":
            suggest = "failure_count_threshold"
        elif key == "intervalSeconds":
            suggest = "interval_seconds"
        elif key == "successCountThreshold":
            suggest = "success_count_threshold"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplateContainerReadinessProbe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplateContainerReadinessProbe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplateContainerReadinessProbe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: int,
                 transport: str,
                 failure_count_threshold: Optional[int] = None,
                 headers: Optional[Sequence['outputs.AppTemplateContainerReadinessProbeHeader']] = None,
                 host: Optional[str] = None,
                 interval_seconds: Optional[int] = None,
                 path: Optional[str] = None,
                 success_count_threshold: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param int port: The port number on which to connect. Possible values are between `1` and `65535`.
        :param str transport: Type of probe. Possible values are `TCP`, `HTTP`, and `HTTPS`.
        :param int failure_count_threshold: The number of consecutive failures required to consider this probe as failed. Possible values are between `1` and `10`. Defaults to `3`.
        :param Sequence['AppTemplateContainerReadinessProbeHeaderArgs'] headers: A `header` block as detailed below.
        :param str host: The probe hostname. Defaults to the pod IP address. Setting a value for `Host` in `headers` can be used to override this for `HTTP` and `HTTPS` type probes.
        :param int interval_seconds: How often, in seconds, the probe should run. Possible values are between `1` and `240`. Defaults to `10`
        :param str path: The URI to use for http type probes. Not valid for `TCP` type probes. Defaults to `/`.
        :param int success_count_threshold: The number of consecutive successful responses required to consider this probe as successful. Possible values are between `1` and `10`. Defaults to `3`.
        :param int timeout: Time in seconds after which the probe times out. Possible values are in the range `1` - `240`. Defaults to `1`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "transport", transport)
        if failure_count_threshold is not None:
            pulumi.set(__self__, "failure_count_threshold", failure_count_threshold)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if interval_seconds is not None:
            pulumi.set(__self__, "interval_seconds", interval_seconds)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if success_count_threshold is not None:
            pulumi.set(__self__, "success_count_threshold", success_count_threshold)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number on which to connect. Possible values are between `1` and `65535`.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def transport(self) -> str:
        """
        Type of probe. Possible values are `TCP`, `HTTP`, and `HTTPS`.
        """
        return pulumi.get(self, "transport")

    @property
    @pulumi.getter(name="failureCountThreshold")
    def failure_count_threshold(self) -> Optional[int]:
        """
        The number of consecutive failures required to consider this probe as failed. Possible values are between `1` and `10`. Defaults to `3`.
        """
        return pulumi.get(self, "failure_count_threshold")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Sequence['outputs.AppTemplateContainerReadinessProbeHeader']]:
        """
        A `header` block as detailed below.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        The probe hostname. Defaults to the pod IP address. Setting a value for `Host` in `headers` can be used to override this for `HTTP` and `HTTPS` type probes.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter(name="intervalSeconds")
    def interval_seconds(self) -> Optional[int]:
        """
        How often, in seconds, the probe should run. Possible values are between `1` and `240`. Defaults to `10`
        """
        return pulumi.get(self, "interval_seconds")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The URI to use for http type probes. Not valid for `TCP` type probes. Defaults to `/`.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="successCountThreshold")
    def success_count_threshold(self) -> Optional[int]:
        """
        The number of consecutive successful responses required to consider this probe as successful. Possible values are between `1` and `10`. Defaults to `3`.
        """
        return pulumi.get(self, "success_count_threshold")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        """
        Time in seconds after which the probe times out. Possible values are in the range `1` - `240`. Defaults to `1`.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class AppTemplateContainerReadinessProbeHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The HTTP Header Name.
        :param str value: The HTTP Header value.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The HTTP Header Name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The HTTP Header value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class AppTemplateContainerStartupProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureCountThreshold":
            suggest = "failure_count_threshold"
        elif key == "intervalSeconds":
            suggest = "interval_seconds"
        elif key == "terminationGracePeriodSeconds":
            suggest = "termination_grace_period_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplateContainerStartupProbe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplateContainerStartupProbe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplateContainerStartupProbe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: int,
                 transport: str,
                 failure_count_threshold: Optional[int] = None,
                 headers: Optional[Sequence['outputs.AppTemplateContainerStartupProbeHeader']] = None,
                 host: Optional[str] = None,
                 interval_seconds: Optional[int] = None,
                 path: Optional[str] = None,
                 termination_grace_period_seconds: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param int port: The port number on which to connect. Possible values are between `1` and `65535`.
        :param str transport: Type of probe. Possible values are `TCP`, `HTTP`, and `HTTPS`.
        :param int failure_count_threshold: The number of consecutive failures required to consider this probe as failed. Possible values are between `1` and `10`. Defaults to `3`.
        :param Sequence['AppTemplateContainerStartupProbeHeaderArgs'] headers: A `header` block as detailed below.
        :param str host: The value for the host header which should be sent with this probe. If unspecified, the IP Address of the Pod is used as the host header. Setting a value for `Host` in `headers` can be used to override this for `HTTP` and `HTTPS` type probes.
        :param int interval_seconds: How often, in seconds, the probe should run. Possible values are between `1` and `240`. Defaults to `10`
        :param str path: The URI to use with the `host` for http type probes. Not valid for `TCP` type probes. Defaults to `/`.
        :param int termination_grace_period_seconds: The time in seconds after the container is sent the termination signal before the process if forcibly killed.
        :param int timeout: Time in seconds after which the probe times out. Possible values are in the range `1` - `240`. Defaults to `1`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "transport", transport)
        if failure_count_threshold is not None:
            pulumi.set(__self__, "failure_count_threshold", failure_count_threshold)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if interval_seconds is not None:
            pulumi.set(__self__, "interval_seconds", interval_seconds)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if termination_grace_period_seconds is not None:
            pulumi.set(__self__, "termination_grace_period_seconds", termination_grace_period_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number on which to connect. Possible values are between `1` and `65535`.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def transport(self) -> str:
        """
        Type of probe. Possible values are `TCP`, `HTTP`, and `HTTPS`.
        """
        return pulumi.get(self, "transport")

    @property
    @pulumi.getter(name="failureCountThreshold")
    def failure_count_threshold(self) -> Optional[int]:
        """
        The number of consecutive failures required to consider this probe as failed. Possible values are between `1` and `10`. Defaults to `3`.
        """
        return pulumi.get(self, "failure_count_threshold")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Sequence['outputs.AppTemplateContainerStartupProbeHeader']]:
        """
        A `header` block as detailed below.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        The value for the host header which should be sent with this probe. If unspecified, the IP Address of the Pod is used as the host header. Setting a value for `Host` in `headers` can be used to override this for `HTTP` and `HTTPS` type probes.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter(name="intervalSeconds")
    def interval_seconds(self) -> Optional[int]:
        """
        How often, in seconds, the probe should run. Possible values are between `1` and `240`. Defaults to `10`
        """
        return pulumi.get(self, "interval_seconds")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The URI to use with the `host` for http type probes. Not valid for `TCP` type probes. Defaults to `/`.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="terminationGracePeriodSeconds")
    def termination_grace_period_seconds(self) -> Optional[int]:
        """
        The time in seconds after the container is sent the termination signal before the process if forcibly killed.
        """
        return pulumi.get(self, "termination_grace_period_seconds")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        """
        Time in seconds after which the probe times out. Possible values are in the range `1` - `240`. Defaults to `1`.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class AppTemplateContainerStartupProbeHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The HTTP Header Name.
        :param str value: The HTTP Header value.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The HTTP Header Name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The HTTP Header value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class AppTemplateContainerVolumeMount(dict):
    def __init__(__self__, *,
                 name: str,
                 path: str):
        """
        :param str name: The name of the Volume to be mounted in the container.
        :param str path: The path in the container at which to mount this volume.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Volume to be mounted in the container.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The path in the container at which to mount this volume.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class AppTemplateVolume(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "storageName":
            suggest = "storage_name"
        elif key == "storageType":
            suggest = "storage_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AppTemplateVolume. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AppTemplateVolume.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AppTemplateVolume.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 storage_name: Optional[str] = None,
                 storage_type: Optional[str] = None):
        """
        :param str name: The name of the volume.
        :param str storage_name: The name of the `AzureFile` storage.
        :param str storage_type: The type of storage volume. Possible values include `AzureFile` and `EmptyDir`. Defaults to `EmptyDir`.
        """
        pulumi.set(__self__, "name", name)
        if storage_name is not None:
            pulumi.set(__self__, "storage_name", storage_name)
        if storage_type is not None:
            pulumi.set(__self__, "storage_type", storage_type)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the volume.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="storageName")
    def storage_name(self) -> Optional[str]:
        """
        The name of the `AzureFile` storage.
        """
        return pulumi.get(self, "storage_name")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[str]:
        """
        The type of storage volume. Possible values include `AzureFile` and `EmptyDir`. Defaults to `EmptyDir`.
        """
        return pulumi.get(self, "storage_type")


@pulumi.output_type
class EnvironmentDaprComponentMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentDaprComponentMetadata. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentDaprComponentMetadata.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentDaprComponentMetadata.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 secret_name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str name: The name of the Metadata configuration item.
        :param str secret_name: The name of a secret specified in the `secrets` block that contains the value for this metadata configuration item.
        :param str value: The value for this metadata configuration item.
        """
        pulumi.set(__self__, "name", name)
        if secret_name is not None:
            pulumi.set(__self__, "secret_name", secret_name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Metadata configuration item.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> Optional[str]:
        """
        The name of a secret specified in the `secrets` block that contains the value for this metadata configuration item.
        """
        return pulumi.get(self, "secret_name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        The value for this metadata configuration item.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class EnvironmentDaprComponentSecret(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The Secret name.
        :param str value: The value for this secret.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Secret name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value for this secret.
        """
        return pulumi.get(self, "value")


