# coding=utf-8
# *** WARNING: this file was generated by crd2pulumi. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables

__all__ = [
    'StorageClusterSpecArgs',
    'StorageClusterSpecAutopilotArgs',
    'StorageClusterSpecAutopilotEnvArgs',
    'StorageClusterSpecAutopilotEnvValueFromArgs',
    'StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecAutopilotEnvValueFromFieldRefArgs',
    'StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecAutopilotProvidersArgs',
    'StorageClusterSpecCloudStorageArgs',
    'StorageClusterSpecCloudStorageCapacitySpecsArgs',
    'StorageClusterSpecDeleteStrategyArgs',
    'StorageClusterSpecEnvArgs',
    'StorageClusterSpecEnvValueFromArgs',
    'StorageClusterSpecEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecEnvValueFromFieldRefArgs',
    'StorageClusterSpecEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecKvdbArgs',
    'StorageClusterSpecMonitoringArgs',
    'StorageClusterSpecMonitoringPrometheusArgs',
    'StorageClusterSpecNetworkArgs',
    'StorageClusterSpecNodesArgs',
    'StorageClusterSpecNodesEnvArgs',
    'StorageClusterSpecNodesEnvValueFromArgs',
    'StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecNodesEnvValueFromFieldRefArgs',
    'StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecNodesNetworkArgs',
    'StorageClusterSpecNodesSelectorArgs',
    'StorageClusterSpecNodesSelectorLabelSelectorArgs',
    'StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs',
    'StorageClusterSpecNodesStorageArgs',
    'StorageClusterSpecPlacementArgs',
    'StorageClusterSpecPlacementNodeAffinityArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs',
    'StorageClusterSpecPlacementTolerationsArgs',
    'StorageClusterSpecStorageArgs',
    'StorageClusterSpecStorkArgs',
    'StorageClusterSpecStorkEnvArgs',
    'StorageClusterSpecStorkEnvValueFromArgs',
    'StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecStorkEnvValueFromFieldRefArgs',
    'StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecUpdateStrategyArgs',
    'StorageClusterSpecUpdateStrategyRollingUpdateArgs',
    'StorageClusterSpecUserInterfaceArgs',
    'StorageClusterSpecUserInterfaceEnvArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs',
    'StorageClusterStatusArgs',
    'StorageClusterStatusConditionsArgs',
    'StorageClusterStatusStorageArgs',
    'StorageNodeSpecArgs',
    'StorageNodeSpecCloudStorageArgs',
    'StorageNodeSpecCloudStorageDriveConfigsArgs',
    'StorageNodeStatusArgs',
    'StorageNodeStatusConditionsArgs',
    'StorageNodeStatusGeographyArgs',
    'StorageNodeStatusNetworkArgs',
]

@pulumi.input_type
class StorageClusterSpecArgs:
    def __init__(__self__, *,
                 autopilot: Optional[pulumi.Input['StorageClusterSpecAutopilotArgs']] = None,
                 cloud_storage: Optional[pulumi.Input['StorageClusterSpecCloudStorageArgs']] = None,
                 custom_image_registry: Optional[pulumi.Input[str]] = None,
                 delete_strategy: Optional[pulumi.Input['StorageClusterSpecDeleteStrategyArgs']] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]]] = None,
                 feature_gates: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 image_pull_policy: Optional[pulumi.Input[str]] = None,
                 image_pull_secret: Optional[pulumi.Input[str]] = None,
                 kvdb: Optional[pulumi.Input['StorageClusterSpecKvdbArgs']] = None,
                 monitoring: Optional[pulumi.Input['StorageClusterSpecMonitoringArgs']] = None,
                 network: Optional[pulumi.Input['StorageClusterSpecNetworkArgs']] = None,
                 nodes: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]]] = None,
                 placement: Optional[pulumi.Input['StorageClusterSpecPlacementArgs']] = None,
                 revision_history_limit: Optional[pulumi.Input[int]] = None,
                 runtime_options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 secrets_provider: Optional[pulumi.Input[str]] = None,
                 start_port: Optional[pulumi.Input[int]] = None,
                 storage: Optional[pulumi.Input['StorageClusterSpecStorageArgs']] = None,
                 stork: Optional[pulumi.Input['StorageClusterSpecStorkArgs']] = None,
                 update_strategy: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyArgs']] = None,
                 user_interface: Optional[pulumi.Input['StorageClusterSpecUserInterfaceArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        The desired behavior of the storage cluster.
        :param pulumi.Input['StorageClusterSpecAutopilotArgs'] autopilot: Contains spec of autopilot component for storage driver.
        :param pulumi.Input['StorageClusterSpecCloudStorageArgs'] cloud_storage: Details of storage used in cloud environment.
        :param pulumi.Input[str] custom_image_registry: Custom container image registry server that will be used instead of index.docker.io to download Docker images. This may include the repository as well. (Example: myregistry.net:5443 or myregistry.com/myrepository)
        :param pulumi.Input['StorageClusterSpecDeleteStrategyArgs'] delete_strategy: Delete strategy to uninstall and wipe the storage cluster.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]] env: List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[Mapping[str, Any]] feature_gates: This is a map of feature names to string values.
        :param pulumi.Input[str] image: Docker image of the storage driver.
        :param pulumi.Input[str] image_pull_policy: Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always.
        :param pulumi.Input[str] image_pull_secret: Image pull secret is a reference to secret in the same namespace as the StorageCluster. It is used for pulling all images used by the StorageCluster.
        :param pulumi.Input['StorageClusterSpecKvdbArgs'] kvdb: Details of KVDB that the storage driver will use.
        :param pulumi.Input['StorageClusterSpecMonitoringArgs'] monitoring: Contains monitoring configuration for the storage cluster.
        :param pulumi.Input['StorageClusterSpecNetworkArgs'] network: Contains network information that is needed by the storage driver.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]] nodes: Node level configurations that will override the configuration at cluster level. These configurations can be for individual nodes or can be grouped to override configuration of multiple nodes based on label selectors.
        :param pulumi.Input['StorageClusterSpecPlacementArgs'] placement: Describes placement configuration for the storage cluster pods.
        :param pulumi.Input[int] revision_history_limit: The number of old history to retain to allow rollback. This is a pointer to distinguish between an explicit zero and not specified. Defaults to 10.
        :param pulumi.Input[Mapping[str, Any]] runtime_options: This is map of any runtime options that need to be sent to the storage driver. The value is a string.
        :param pulumi.Input[str] secrets_provider: Secrets provider is the name of secret provider that driver will connect to.
        :param pulumi.Input[int] start_port: Start port is the starting port in the range of ports used by the cluster.
        :param pulumi.Input['StorageClusterSpecStorageArgs'] storage: Details of the storage used by the storage driver.
        :param pulumi.Input['StorageClusterSpecStorkArgs'] stork: Contains STORK related spec.
        :param pulumi.Input['StorageClusterSpecUpdateStrategyArgs'] update_strategy: An update strategy to replace existing StorageCluster pods with new pods.
        :param pulumi.Input['StorageClusterSpecUserInterfaceArgs'] user_interface: Contains spec of a user interface for the storage driver.
        :param pulumi.Input[str] version: Version of the storage driver. This field is read-only.
        """
        if autopilot is not None:
            pulumi.set(__self__, "autopilot", autopilot)
        if cloud_storage is not None:
            pulumi.set(__self__, "cloud_storage", cloud_storage)
        if custom_image_registry is not None:
            pulumi.set(__self__, "custom_image_registry", custom_image_registry)
        if delete_strategy is not None:
            pulumi.set(__self__, "delete_strategy", delete_strategy)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if feature_gates is not None:
            pulumi.set(__self__, "feature_gates", feature_gates)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if kvdb is not None:
            pulumi.set(__self__, "kvdb", kvdb)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if placement is not None:
            pulumi.set(__self__, "placement", placement)
        if revision_history_limit is not None:
            pulumi.set(__self__, "revision_history_limit", revision_history_limit)
        if runtime_options is not None:
            pulumi.set(__self__, "runtime_options", runtime_options)
        if secrets_provider is not None:
            pulumi.set(__self__, "secrets_provider", secrets_provider)
        if start_port is not None:
            pulumi.set(__self__, "start_port", start_port)
        if storage is not None:
            pulumi.set(__self__, "storage", storage)
        if stork is not None:
            pulumi.set(__self__, "stork", stork)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if user_interface is not None:
            pulumi.set(__self__, "user_interface", user_interface)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def autopilot(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotArgs']]:
        """
        Contains spec of autopilot component for storage driver.
        """
        return pulumi.get(self, "autopilot")

    @autopilot.setter
    def autopilot(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotArgs']]):
        pulumi.set(self, "autopilot", value)

    @property
    @pulumi.getter(name="cloudStorage")
    def cloud_storage(self) -> Optional[pulumi.Input['StorageClusterSpecCloudStorageArgs']]:
        """
        Details of storage used in cloud environment.
        """
        return pulumi.get(self, "cloud_storage")

    @cloud_storage.setter
    def cloud_storage(self, value: Optional[pulumi.Input['StorageClusterSpecCloudStorageArgs']]):
        pulumi.set(self, "cloud_storage", value)

    @property
    @pulumi.getter(name="customImageRegistry")
    def custom_image_registry(self) -> Optional[pulumi.Input[str]]:
        """
        Custom container image registry server that will be used instead of index.docker.io to download Docker images. This may include the repository as well. (Example: myregistry.net:5443 or myregistry.com/myrepository)
        """
        return pulumi.get(self, "custom_image_registry")

    @custom_image_registry.setter
    def custom_image_registry(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_image_registry", value)

    @property
    @pulumi.getter(name="deleteStrategy")
    def delete_strategy(self) -> Optional[pulumi.Input['StorageClusterSpecDeleteStrategyArgs']]:
        """
        Delete strategy to uninstall and wipe the storage cluster.
        """
        return pulumi.get(self, "delete_strategy")

    @delete_strategy.setter
    def delete_strategy(self, value: Optional[pulumi.Input['StorageClusterSpecDeleteStrategyArgs']]):
        pulumi.set(self, "delete_strategy", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]]]:
        """
        List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter(name="featureGates")
    def feature_gates(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        This is a map of feature names to string values.
        """
        return pulumi.get(self, "feature_gates")

    @feature_gates.setter
    def feature_gates(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "feature_gates", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the storage driver.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always.
        """
        return pulumi.get(self, "image_pull_policy")

    @image_pull_policy.setter
    def image_pull_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_pull_policy", value)

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[pulumi.Input[str]]:
        """
        Image pull secret is a reference to secret in the same namespace as the StorageCluster. It is used for pulling all images used by the StorageCluster.
        """
        return pulumi.get(self, "image_pull_secret")

    @image_pull_secret.setter
    def image_pull_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_pull_secret", value)

    @property
    @pulumi.getter
    def kvdb(self) -> Optional[pulumi.Input['StorageClusterSpecKvdbArgs']]:
        """
        Details of KVDB that the storage driver will use.
        """
        return pulumi.get(self, "kvdb")

    @kvdb.setter
    def kvdb(self, value: Optional[pulumi.Input['StorageClusterSpecKvdbArgs']]):
        pulumi.set(self, "kvdb", value)

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input['StorageClusterSpecMonitoringArgs']]:
        """
        Contains monitoring configuration for the storage cluster.
        """
        return pulumi.get(self, "monitoring")

    @monitoring.setter
    def monitoring(self, value: Optional[pulumi.Input['StorageClusterSpecMonitoringArgs']]):
        pulumi.set(self, "monitoring", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['StorageClusterSpecNetworkArgs']]:
        """
        Contains network information that is needed by the storage driver.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['StorageClusterSpecNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter
    def nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]]]:
        """
        Node level configurations that will override the configuration at cluster level. These configurations can be for individual nodes or can be grouped to override configuration of multiple nodes based on label selectors.
        """
        return pulumi.get(self, "nodes")

    @nodes.setter
    def nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]]]):
        pulumi.set(self, "nodes", value)

    @property
    @pulumi.getter
    def placement(self) -> Optional[pulumi.Input['StorageClusterSpecPlacementArgs']]:
        """
        Describes placement configuration for the storage cluster pods.
        """
        return pulumi.get(self, "placement")

    @placement.setter
    def placement(self, value: Optional[pulumi.Input['StorageClusterSpecPlacementArgs']]):
        pulumi.set(self, "placement", value)

    @property
    @pulumi.getter(name="revisionHistoryLimit")
    def revision_history_limit(self) -> Optional[pulumi.Input[int]]:
        """
        The number of old history to retain to allow rollback. This is a pointer to distinguish between an explicit zero and not specified. Defaults to 10.
        """
        return pulumi.get(self, "revision_history_limit")

    @revision_history_limit.setter
    def revision_history_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "revision_history_limit", value)

    @property
    @pulumi.getter(name="runtimeOptions")
    def runtime_options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        This is map of any runtime options that need to be sent to the storage driver. The value is a string.
        """
        return pulumi.get(self, "runtime_options")

    @runtime_options.setter
    def runtime_options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "runtime_options", value)

    @property
    @pulumi.getter(name="secretsProvider")
    def secrets_provider(self) -> Optional[pulumi.Input[str]]:
        """
        Secrets provider is the name of secret provider that driver will connect to.
        """
        return pulumi.get(self, "secrets_provider")

    @secrets_provider.setter
    def secrets_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secrets_provider", value)

    @property
    @pulumi.getter(name="startPort")
    def start_port(self) -> Optional[pulumi.Input[int]]:
        """
        Start port is the starting port in the range of ports used by the cluster.
        """
        return pulumi.get(self, "start_port")

    @start_port.setter
    def start_port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "start_port", value)

    @property
    @pulumi.getter
    def storage(self) -> Optional[pulumi.Input['StorageClusterSpecStorageArgs']]:
        """
        Details of the storage used by the storage driver.
        """
        return pulumi.get(self, "storage")

    @storage.setter
    def storage(self, value: Optional[pulumi.Input['StorageClusterSpecStorageArgs']]):
        pulumi.set(self, "storage", value)

    @property
    @pulumi.getter
    def stork(self) -> Optional[pulumi.Input['StorageClusterSpecStorkArgs']]:
        """
        Contains STORK related spec.
        """
        return pulumi.get(self, "stork")

    @stork.setter
    def stork(self, value: Optional[pulumi.Input['StorageClusterSpecStorkArgs']]):
        pulumi.set(self, "stork", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['StorageClusterSpecUpdateStrategyArgs']]:
        """
        An update strategy to replace existing StorageCluster pods with new pods.
        """
        return pulumi.get(self, "update_strategy")

    @update_strategy.setter
    def update_strategy(self, value: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyArgs']]):
        pulumi.set(self, "update_strategy", value)

    @property
    @pulumi.getter(name="userInterface")
    def user_interface(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceArgs']]:
        """
        Contains spec of a user interface for the storage driver.
        """
        return pulumi.get(self, "user_interface")

    @user_interface.setter
    def user_interface(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceArgs']]):
        pulumi.set(self, "user_interface", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        Version of the storage driver. This field is read-only.
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class StorageClusterSpecAutopilotArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 lock_image: Optional[pulumi.Input[bool]] = None,
                 providers: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]]] = None):
        """
        Contains spec of autopilot component for storage driver.
        :param pulumi.Input[Mapping[str, Any]] args: It is a map of arguments provided to autopilot. Example: log-level: debug
        :param pulumi.Input[bool] enabled: Flag indicating whether autopilot needs to be enabled.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]] env: List of environment variables used by autopilot. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[str] image: Docker image of the autopilot container.
        :param pulumi.Input[bool] lock_image: Flag indicating if the autopilot image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]] providers: List of input data providers to autopilot.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if lock_image is not None:
            pulumi.set(__self__, "lock_image", lock_image)
        if providers is not None:
            pulumi.set(__self__, "providers", providers)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        It is a map of arguments provided to autopilot. Example: log-level: debug
        """
        return pulumi.get(self, "args")

    @args.setter
    def args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "args", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether autopilot needs to be enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]]]:
        """
        List of environment variables used by autopilot. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the autopilot container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="lockImage")
    def lock_image(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating if the autopilot image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        return pulumi.get(self, "lock_image")

    @lock_image.setter
    def lock_image(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lock_image", value)

    @property
    @pulumi.getter
    def providers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]]]:
        """
        List of input data providers to autopilot.
        """
        return pulumi.get(self, "providers")

    @providers.setter
    def providers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]]]):
        pulumi.set(self, "providers", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecAutopilotProvidersArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 params: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: Unique name of the data provider.
        :param pulumi.Input[Mapping[str, Any]] params: Map of key-value params for the provider.
        :param pulumi.Input[str] type: Type of the data provider. For instance - prometheus
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if params is not None:
            pulumi.set(__self__, "params", params)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Unique name of the data provider.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Map of key-value params for the provider.
        """
        return pulumi.get(self, "params")

    @params.setter
    def params(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "params", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the data provider. For instance - prometheus
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterSpecCloudStorageArgs:
    def __init__(__self__, *,
                 capacity_specs: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]]] = None,
                 device_specs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 journal_device_spec: Optional[pulumi.Input[str]] = None,
                 kvdb_device_spec: Optional[pulumi.Input[str]] = None,
                 max_storage_nodes: Optional[pulumi.Input[int]] = None,
                 max_storage_nodes_per_zone: Optional[pulumi.Input[int]] = None,
                 system_metadata_device_spec: Optional[pulumi.Input[str]] = None):
        """
        Details of storage used in cloud environment.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]] capacity_specs: List of cluster wide storage types and their capacities. A single capacity spec identifies a storage pool with a set of minimum requested IOPS and size. Based on the cloud provider, the total storage capacity will get divided amongst the nodes. The nodes bearing storage themselves will get uniformly distributed across all the zones.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] device_specs: List of storage device specs. A cloud storage device will be created for every spec in the list. The specs will be applied to all nodes in the cluster up to spec.cloudStorage.maxStorageNodes or spec.cloudStorage.maxStorageNodesPerZone. This will be ignored if spec.cloudStorage.capacitySpecs is present.
        :param pulumi.Input[str] journal_device_spec: Device spec for the journal device.
        :param pulumi.Input[str] kvdb_device_spec: Device spec for internal KVDB device.
        :param pulumi.Input[int] max_storage_nodes: Maximum nodes that will have storage in the cluster.
        :param pulumi.Input[int] max_storage_nodes_per_zone: Maximum nodes in every zone that will have storage in the cluster.
        :param pulumi.Input[str] system_metadata_device_spec: Device spec for the metadata device. This device will be used to store system metadata by the driver.
        """
        if capacity_specs is not None:
            pulumi.set(__self__, "capacity_specs", capacity_specs)
        if device_specs is not None:
            pulumi.set(__self__, "device_specs", device_specs)
        if journal_device_spec is not None:
            pulumi.set(__self__, "journal_device_spec", journal_device_spec)
        if kvdb_device_spec is not None:
            pulumi.set(__self__, "kvdb_device_spec", kvdb_device_spec)
        if max_storage_nodes is not None:
            pulumi.set(__self__, "max_storage_nodes", max_storage_nodes)
        if max_storage_nodes_per_zone is not None:
            pulumi.set(__self__, "max_storage_nodes_per_zone", max_storage_nodes_per_zone)
        if system_metadata_device_spec is not None:
            pulumi.set(__self__, "system_metadata_device_spec", system_metadata_device_spec)

    @property
    @pulumi.getter(name="capacitySpecs")
    def capacity_specs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]]]:
        """
        List of cluster wide storage types and their capacities. A single capacity spec identifies a storage pool with a set of minimum requested IOPS and size. Based on the cloud provider, the total storage capacity will get divided amongst the nodes. The nodes bearing storage themselves will get uniformly distributed across all the zones.
        """
        return pulumi.get(self, "capacity_specs")

    @capacity_specs.setter
    def capacity_specs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]]]):
        pulumi.set(self, "capacity_specs", value)

    @property
    @pulumi.getter(name="deviceSpecs")
    def device_specs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of storage device specs. A cloud storage device will be created for every spec in the list. The specs will be applied to all nodes in the cluster up to spec.cloudStorage.maxStorageNodes or spec.cloudStorage.maxStorageNodesPerZone. This will be ignored if spec.cloudStorage.capacitySpecs is present.
        """
        return pulumi.get(self, "device_specs")

    @device_specs.setter
    def device_specs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "device_specs", value)

    @property
    @pulumi.getter(name="journalDeviceSpec")
    def journal_device_spec(self) -> Optional[pulumi.Input[str]]:
        """
        Device spec for the journal device.
        """
        return pulumi.get(self, "journal_device_spec")

    @journal_device_spec.setter
    def journal_device_spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "journal_device_spec", value)

    @property
    @pulumi.getter(name="kvdbDeviceSpec")
    def kvdb_device_spec(self) -> Optional[pulumi.Input[str]]:
        """
        Device spec for internal KVDB device.
        """
        return pulumi.get(self, "kvdb_device_spec")

    @kvdb_device_spec.setter
    def kvdb_device_spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvdb_device_spec", value)

    @property
    @pulumi.getter(name="maxStorageNodes")
    def max_storage_nodes(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum nodes that will have storage in the cluster.
        """
        return pulumi.get(self, "max_storage_nodes")

    @max_storage_nodes.setter
    def max_storage_nodes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_storage_nodes", value)

    @property
    @pulumi.getter(name="maxStorageNodesPerZone")
    def max_storage_nodes_per_zone(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum nodes in every zone that will have storage in the cluster.
        """
        return pulumi.get(self, "max_storage_nodes_per_zone")

    @max_storage_nodes_per_zone.setter
    def max_storage_nodes_per_zone(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_storage_nodes_per_zone", value)

    @property
    @pulumi.getter(name="systemMetadataDeviceSpec")
    def system_metadata_device_spec(self) -> Optional[pulumi.Input[str]]:
        """
        Device spec for the metadata device. This device will be used to store system metadata by the driver.
        """
        return pulumi.get(self, "system_metadata_device_spec")

    @system_metadata_device_spec.setter
    def system_metadata_device_spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "system_metadata_device_spec", value)


@pulumi.input_type
class StorageClusterSpecCloudStorageCapacitySpecsArgs:
    def __init__(__self__, *,
                 max_capacity_in_gi_b: Optional[pulumi.Input[int]] = None,
                 min_capacity_in_gi_b: Optional[pulumi.Input[int]] = None,
                 min_iops: Optional[pulumi.Input[int]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[int] max_capacity_in_gi_b: Maximum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be greater than this number for the entire cluster.
        :param pulumi.Input[int] min_capacity_in_gi_b: Minimum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be less than this number for the entire cluster.
        :param pulumi.Input[int] min_iops: Minimum IOPS expected from the cloud drive.
        :param pulumi.Input[Mapping[str, Any]] options: Additional options required to provision the drive in cloud.
        """
        if max_capacity_in_gi_b is not None:
            pulumi.set(__self__, "max_capacity_in_gi_b", max_capacity_in_gi_b)
        if min_capacity_in_gi_b is not None:
            pulumi.set(__self__, "min_capacity_in_gi_b", min_capacity_in_gi_b)
        if min_iops is not None:
            pulumi.set(__self__, "min_iops", min_iops)
        if options is not None:
            pulumi.set(__self__, "options", options)

    @property
    @pulumi.getter(name="maxCapacityInGiB")
    def max_capacity_in_gi_b(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be greater than this number for the entire cluster.
        """
        return pulumi.get(self, "max_capacity_in_gi_b")

    @max_capacity_in_gi_b.setter
    def max_capacity_in_gi_b(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_capacity_in_gi_b", value)

    @property
    @pulumi.getter(name="minCapacityInGiB")
    def min_capacity_in_gi_b(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be less than this number for the entire cluster.
        """
        return pulumi.get(self, "min_capacity_in_gi_b")

    @min_capacity_in_gi_b.setter
    def min_capacity_in_gi_b(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_capacity_in_gi_b", value)

    @property
    @pulumi.getter(name="minIOPS")
    def min_iops(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum IOPS expected from the cloud drive.
        """
        return pulumi.get(self, "min_iops")

    @min_iops.setter
    def min_iops(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_iops", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Additional options required to provision the drive in cloud.
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)


@pulumi.input_type
class StorageClusterSpecDeleteStrategyArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input[str]] = None):
        """
        Delete strategy to uninstall and wipe the storage cluster.
        :param pulumi.Input[str] type: Type of storage cluster delete. Can be Uninstall or UninstallAndWipe. There is no default delete strategy. When no delete strategy only objects managed by the StorageCluster controller and owned by the StorageCluster object are deleted. The storage driver will be left in a state where it will not be managed by any object. Uninstall strategy ensures that the cluster is completely uninstalled even from the storage driver perspective. UninstallAndWipe strategy ensures that the cluster is completely uninstalled as well as the storage devices and metadata are wiped for reuse. This may result in data loss.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of storage cluster delete. Can be Uninstall or UninstallAndWipe. There is no default delete strategy. When no delete strategy only objects managed by the StorageCluster controller and owned by the StorageCluster object are deleted. The storage driver will be left in a state where it will not be managed by any object. Uninstall strategy ensures that the cluster is completely uninstalled even from the storage driver perspective. UninstallAndWipe strategy ensures that the cluster is completely uninstalled as well as the storage devices and metadata are wiped for reuse. This may result in data loss.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterSpecEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecKvdbArgs:
    def __init__(__self__, *,
                 auth_secret: Optional[pulumi.Input[str]] = None,
                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 internal: Optional[pulumi.Input[bool]] = None):
        """
        Details of KVDB that the storage driver will use.
        :param pulumi.Input[str] auth_secret: Authentication secret is the name of Kubernetes secret containing information to authenticate with the external KVDB. It could have the username/password for basic auth, certificate information or an ACL token.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] endpoints: If using external KVDB, this is the list of KVDB endpoints.
        :param pulumi.Input[bool] internal: Flag indicating whether to use internal KVDB or an external KVDB.
        """
        if auth_secret is not None:
            pulumi.set(__self__, "auth_secret", auth_secret)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if internal is not None:
            pulumi.set(__self__, "internal", internal)

    @property
    @pulumi.getter(name="authSecret")
    def auth_secret(self) -> Optional[pulumi.Input[str]]:
        """
        Authentication secret is the name of Kubernetes secret containing information to authenticate with the external KVDB. It could have the username/password for basic auth, certificate information or an ACL token.
        """
        return pulumi.get(self, "auth_secret")

    @auth_secret.setter
    def auth_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_secret", value)

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        If using external KVDB, this is the list of KVDB endpoints.
        """
        return pulumi.get(self, "endpoints")

    @endpoints.setter
    def endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "endpoints", value)

    @property
    @pulumi.getter
    def internal(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether to use internal KVDB or an external KVDB.
        """
        return pulumi.get(self, "internal")

    @internal.setter
    def internal(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "internal", value)


@pulumi.input_type
class StorageClusterSpecMonitoringArgs:
    def __init__(__self__, *,
                 enable_metrics: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs']] = None):
        """
        Contains monitoring configuration for the storage cluster.
        :param pulumi.Input[bool] enable_metrics: If this flag is enabled it will expose the storage cluster metrics to external monitoring solutions like Prometheus. DEPRECATED - use prometheus.exportMetrics instead
        :param pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs'] prometheus: Contains configuration of Prometheus to monitor the storage cluster.
        """
        if enable_metrics is not None:
            pulumi.set(__self__, "enable_metrics", enable_metrics)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter(name="enableMetrics")
    def enable_metrics(self) -> Optional[pulumi.Input[bool]]:
        """
        If this flag is enabled it will expose the storage cluster metrics to external monitoring solutions like Prometheus. DEPRECATED - use prometheus.exportMetrics instead
        """
        return pulumi.get(self, "enable_metrics")

    @enable_metrics.setter
    def enable_metrics(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_metrics", value)

    @property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs']]:
        """
        Contains configuration of Prometheus to monitor the storage cluster.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs']]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class StorageClusterSpecMonitoringPrometheusArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 export_metrics: Optional[pulumi.Input[bool]] = None,
                 remote_write_endpoint: Optional[pulumi.Input[str]] = None):
        """
        Contains configuration of Prometheus to monitor the storage cluster.
        :param pulumi.Input[bool] enabled: Flag indicating whether Prometheus stack needs to be enabled and deployed by the Storage operator.
        :param pulumi.Input[bool] export_metrics: If this flag is enabled it will expose the storage cluster metrics to Prometheus.
        :param pulumi.Input[str] remote_write_endpoint: Specifies the remote write endpoint for Prometheus.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if export_metrics is not None:
            pulumi.set(__self__, "export_metrics", export_metrics)
        if remote_write_endpoint is not None:
            pulumi.set(__self__, "remote_write_endpoint", remote_write_endpoint)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether Prometheus stack needs to be enabled and deployed by the Storage operator.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="exportMetrics")
    def export_metrics(self) -> Optional[pulumi.Input[bool]]:
        """
        If this flag is enabled it will expose the storage cluster metrics to Prometheus.
        """
        return pulumi.get(self, "export_metrics")

    @export_metrics.setter
    def export_metrics(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "export_metrics", value)

    @property
    @pulumi.getter(name="remoteWriteEndpoint")
    def remote_write_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the remote write endpoint for Prometheus.
        """
        return pulumi.get(self, "remote_write_endpoint")

    @remote_write_endpoint.setter
    def remote_write_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "remote_write_endpoint", value)


@pulumi.input_type
class StorageClusterSpecNetworkArgs:
    def __init__(__self__, *,
                 data_interface: Optional[pulumi.Input[str]] = None,
                 mgmt_interface: Optional[pulumi.Input[str]] = None):
        """
        Contains network information that is needed by the storage driver.
        :param pulumi.Input[str] data_interface: Name of the network interface used by the storage driver for data traffic.
        :param pulumi.Input[str] mgmt_interface: Name of the network interface used by the storage driver for management traffic.
        """
        if data_interface is not None:
            pulumi.set(__self__, "data_interface", data_interface)
        if mgmt_interface is not None:
            pulumi.set(__self__, "mgmt_interface", mgmt_interface)

    @property
    @pulumi.getter(name="dataInterface")
    def data_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for data traffic.
        """
        return pulumi.get(self, "data_interface")

    @data_interface.setter
    def data_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_interface", value)

    @property
    @pulumi.getter(name="mgmtInterface")
    def mgmt_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for management traffic.
        """
        return pulumi.get(self, "mgmt_interface")

    @mgmt_interface.setter
    def mgmt_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mgmt_interface", value)


@pulumi.input_type
class StorageClusterSpecNodesArgs:
    def __init__(__self__, *,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]]] = None,
                 network: Optional[pulumi.Input['StorageClusterSpecNodesNetworkArgs']] = None,
                 runtime_options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 selector: Optional[pulumi.Input['StorageClusterSpecNodesSelectorArgs']] = None,
                 storage: Optional[pulumi.Input['StorageClusterSpecNodesStorageArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]] env: List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Environment variables specified here at the node level will be merged with the ones present in cluster configuration and sent to the nodes. If there is duplicate, the node level value will take precedence.
        :param pulumi.Input['StorageClusterSpecNodesNetworkArgs'] network: Contains network information that is needed by the storage driver.
        :param pulumi.Input[Mapping[str, Any]] runtime_options: This is map of any runtime options that need to be sent to the storage driver. The value is a string. If runtime options are present here at node level, they will override the ones from cluster configuration.
        :param pulumi.Input['StorageClusterSpecNodesSelectorArgs'] selector: Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.
        :param pulumi.Input['StorageClusterSpecNodesStorageArgs'] storage: Details of the storage used by the storage driver.
        """
        if env is not None:
            pulumi.set(__self__, "env", env)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if runtime_options is not None:
            pulumi.set(__self__, "runtime_options", runtime_options)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if storage is not None:
            pulumi.set(__self__, "storage", storage)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]]]:
        """
        List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Environment variables specified here at the node level will be merged with the ones present in cluster configuration and sent to the nodes. If there is duplicate, the node level value will take precedence.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['StorageClusterSpecNodesNetworkArgs']]:
        """
        Contains network information that is needed by the storage driver.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['StorageClusterSpecNodesNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="runtimeOptions")
    def runtime_options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        This is map of any runtime options that need to be sent to the storage driver. The value is a string. If runtime options are present here at node level, they will override the ones from cluster configuration.
        """
        return pulumi.get(self, "runtime_options")

    @runtime_options.setter
    def runtime_options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "runtime_options", value)

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input['StorageClusterSpecNodesSelectorArgs']]:
        """
        Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.
        """
        return pulumi.get(self, "selector")

    @selector.setter
    def selector(self, value: Optional[pulumi.Input['StorageClusterSpecNodesSelectorArgs']]):
        pulumi.set(self, "selector", value)

    @property
    @pulumi.getter
    def storage(self) -> Optional[pulumi.Input['StorageClusterSpecNodesStorageArgs']]:
        """
        Details of the storage used by the storage driver.
        """
        return pulumi.get(self, "storage")

    @storage.setter
    def storage(self, value: Optional[pulumi.Input['StorageClusterSpecNodesStorageArgs']]):
        pulumi.set(self, "storage", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecNodesNetworkArgs:
    def __init__(__self__, *,
                 data_interface: Optional[pulumi.Input[str]] = None,
                 mgmt_interface: Optional[pulumi.Input[str]] = None):
        """
        Contains network information that is needed by the storage driver.
        :param pulumi.Input[str] data_interface: Name of the network interface used by the storage driver for data traffic.
        :param pulumi.Input[str] mgmt_interface: Name of the network interface used by the storage driver for management traffic.
        """
        if data_interface is not None:
            pulumi.set(__self__, "data_interface", data_interface)
        if mgmt_interface is not None:
            pulumi.set(__self__, "mgmt_interface", mgmt_interface)

    @property
    @pulumi.getter(name="dataInterface")
    def data_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for data traffic.
        """
        return pulumi.get(self, "data_interface")

    @data_interface.setter
    def data_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_interface", value)

    @property
    @pulumi.getter(name="mgmtInterface")
    def mgmt_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for management traffic.
        """
        return pulumi.get(self, "mgmt_interface")

    @mgmt_interface.setter
    def mgmt_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mgmt_interface", value)


@pulumi.input_type
class StorageClusterSpecNodesSelectorArgs:
    def __init__(__self__, *,
                 label_selector: Optional[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs']] = None,
                 node_name: Optional[pulumi.Input[str]] = None):
        """
        Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.
        :param pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs'] label_selector: It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.
        :param pulumi.Input[str] node_name: Name of the Kubernetes node that is to be selected. If present then the labelSelector is ignored even if the node with the given name is absent and the labelSelector matches another node.
        """
        if label_selector is not None:
            pulumi.set(__self__, "label_selector", label_selector)
        if node_name is not None:
            pulumi.set(__self__, "node_name", node_name)

    @property
    @pulumi.getter(name="labelSelector")
    def label_selector(self) -> Optional[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs']]:
        """
        It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.
        """
        return pulumi.get(self, "label_selector")

    @label_selector.setter
    def label_selector(self, value: Optional[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs']]):
        pulumi.set(self, "label_selector", value)

    @property
    @pulumi.getter(name="nodeName")
    def node_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the Kubernetes node that is to be selected. If present then the labelSelector is ignored even if the node with the given name is absent and the labelSelector matches another node.
        """
        return pulumi.get(self, "node_name")

    @node_name.setter
    def node_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_name", value)


@pulumi.input_type
class StorageClusterSpecNodesSelectorLabelSelectorArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]]] = None,
                 match_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]] match_expressions: It is a list of label selector requirements. The requirements are ANDed.
        :param pulumi.Input[Mapping[str, Any]] match_labels: It is a map of key-value pairs. A single key-value in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]]]:
        """
        It is a list of label selector requirements. The requirements are ANDed.
        """
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        It is a map of key-value pairs. A single key-value in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
        """
        return pulumi.get(self, "match_labels")

    @match_labels.setter
    def match_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "match_labels", value)


@pulumi.input_type
class StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] key: It is the label key that the selector applies to.
        :param pulumi.Input[str] operator: It represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: It is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        It is the label key that the selector applies to.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        It represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        It is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecNodesStorageArgs:
    def __init__(__self__, *,
                 devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 force_use_disks: Optional[pulumi.Input[bool]] = None,
                 journal_device: Optional[pulumi.Input[str]] = None,
                 kvdb_device: Optional[pulumi.Input[str]] = None,
                 system_metadata_device: Optional[pulumi.Input[str]] = None,
                 use_all: Optional[pulumi.Input[bool]] = None,
                 use_all_with_partitions: Optional[pulumi.Input[bool]] = None):
        """
        Details of the storage used by the storage driver.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: List of devices to be used by the storage driver.
        :param pulumi.Input[bool] force_use_disks: Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        :param pulumi.Input[str] journal_device: Device used for journaling.
        :param pulumi.Input[str] kvdb_device: Device used for internal KVDB.
        :param pulumi.Input[str] system_metadata_device: Device that will be used to store system metadata by the driver.
        :param pulumi.Input[bool] use_all: Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        :param pulumi.Input[bool] use_all_with_partitions: Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if force_use_disks is not None:
            pulumi.set(__self__, "force_use_disks", force_use_disks)
        if journal_device is not None:
            pulumi.set(__self__, "journal_device", journal_device)
        if kvdb_device is not None:
            pulumi.set(__self__, "kvdb_device", kvdb_device)
        if system_metadata_device is not None:
            pulumi.set(__self__, "system_metadata_device", system_metadata_device)
        if use_all is not None:
            pulumi.set(__self__, "use_all", use_all)
        if use_all_with_partitions is not None:
            pulumi.set(__self__, "use_all_with_partitions", use_all_with_partitions)

    @property
    @pulumi.getter
    def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of devices to be used by the storage driver.
        """
        return pulumi.get(self, "devices")

    @devices.setter
    def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "devices", value)

    @property
    @pulumi.getter(name="forceUseDisks")
    def force_use_disks(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        """
        return pulumi.get(self, "force_use_disks")

    @force_use_disks.setter
    def force_use_disks(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force_use_disks", value)

    @property
    @pulumi.getter(name="journalDevice")
    def journal_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for journaling.
        """
        return pulumi.get(self, "journal_device")

    @journal_device.setter
    def journal_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "journal_device", value)

    @property
    @pulumi.getter(name="kvdbDevice")
    def kvdb_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for internal KVDB.
        """
        return pulumi.get(self, "kvdb_device")

    @kvdb_device.setter
    def kvdb_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvdb_device", value)

    @property
    @pulumi.getter(name="systemMetadataDevice")
    def system_metadata_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device that will be used to store system metadata by the driver.
        """
        return pulumi.get(self, "system_metadata_device")

    @system_metadata_device.setter
    def system_metadata_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "system_metadata_device", value)

    @property
    @pulumi.getter(name="useAll")
    def use_all(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all")

    @use_all.setter
    def use_all(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all", value)

    @property
    @pulumi.getter(name="useAllWithPartitions")
    def use_all_with_partitions(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all_with_partitions")

    @use_all_with_partitions.setter
    def use_all_with_partitions(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all_with_partitions", value)


@pulumi.input_type
class StorageClusterSpecPlacementArgs:
    def __init__(__self__, *,
                 node_affinity: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs']] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]]] = None):
        """
        Describes placement configuration for the storage cluster pods.
        :param pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]] tolerations: Tolerations for all the pods deployed by the StorageCluster controller. The pod with this toleration attached will tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>.
        """
        if node_affinity is not None:
            pulumi.set(__self__, "node_affinity", node_affinity)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)

    @property
    @pulumi.getter(name="nodeAffinity")
    def node_affinity(self) -> Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs']]:
        """
        Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.
        """
        return pulumi.get(self, "node_affinity")

    @node_affinity.setter
    def node_affinity(self, value: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs']]):
        pulumi.set(self, "node_affinity", value)

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]]]:
        """
        Tolerations for all the pods deployed by the StorageCluster controller. The pod with this toleration attached will tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>.
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]]]):
        pulumi.set(self, "tolerations", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityArgs:
    def __init__(__self__, *,
                 preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]] = None,
                 required_during_scheduling_ignored_during_execution: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']] = None):
        """
        Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.
        """
        if preferred_during_scheduling_ignored_during_execution is not None:
            pulumi.set(__self__, "preferred_during_scheduling_ignored_during_execution", preferred_during_scheduling_ignored_during_execution)
        if required_during_scheduling_ignored_during_execution is not None:
            pulumi.set(__self__, "required_during_scheduling_ignored_during_execution", required_during_scheduling_ignored_during_execution)

    @property
    @pulumi.getter(name="preferredDuringSchedulingIgnoredDuringExecution")
    def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
        return pulumi.get(self, "preferred_during_scheduling_ignored_during_execution")

    @preferred_during_scheduling_ignored_during_execution.setter
    def preferred_during_scheduling_ignored_during_execution(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]):
        pulumi.set(self, "preferred_during_scheduling_ignored_during_execution", value)

    @property
    @pulumi.getter(name="requiredDuringSchedulingIgnoredDuringExecution")
    def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]:
        return pulumi.get(self, "required_during_scheduling_ignored_during_execution")

    @required_during_scheduling_ignored_during_execution.setter
    def required_during_scheduling_ignored_during_execution(self, value: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]):
        pulumi.set(self, "required_during_scheduling_ignored_during_execution", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs:
    def __init__(__self__, *,
                 preference: pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'],
                 weight: pulumi.Input[int]):
        pulumi.set(__self__, "preference", preference)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def preference(self) -> pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']:
        return pulumi.get(self, "preference")

    @preference.setter
    def preference(self, value: pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']):
        pulumi.set(self, "preference", value)

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[int]:
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[int]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]] = None,
                 match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]] = None):
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_fields is not None:
            pulumi.set(__self__, "match_fields", match_fields)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]:
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchFields")
    def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]:
        return pulumi.get(self, "match_fields")

    @match_fields.setter
    def match_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]):
        pulumi.set(self, "match_fields", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs:
    def __init__(__self__, *,
                 node_selector_terms: pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
        pulumi.set(__self__, "node_selector_terms", node_selector_terms)

    @property
    @pulumi.getter(name="nodeSelectorTerms")
    def node_selector_terms(self) -> pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]:
        return pulumi.get(self, "node_selector_terms")

    @node_selector_terms.setter
    def node_selector_terms(self, value: pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
        pulumi.set(self, "node_selector_terms", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]] = None,
                 match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]] = None):
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_fields is not None:
            pulumi.set(__self__, "match_fields", match_fields)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]:
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchFields")
    def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]:
        return pulumi.get(self, "match_fields")

    @match_fields.setter
    def match_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]):
        pulumi.set(self, "match_fields", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementTolerationsArgs:
    def __init__(__self__, *,
                 effect: Optional[pulumi.Input[str]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 toleration_seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
        :param pulumi.Input[str] key: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
        :param pulumi.Input[str] operator: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
        :param pulumi.Input[int] toleration_seconds: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
        :param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
        """
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if toleration_seconds is not None:
            pulumi.set(__self__, "toleration_seconds", toleration_seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input[str]]:
        """
        Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
        """
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter(name="tolerationSeconds")
    def toleration_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
        """
        return pulumi.get(self, "toleration_seconds")

    @toleration_seconds.setter
    def toleration_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "toleration_seconds", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class StorageClusterSpecStorageArgs:
    def __init__(__self__, *,
                 devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 force_use_disks: Optional[pulumi.Input[bool]] = None,
                 journal_device: Optional[pulumi.Input[str]] = None,
                 kvdb_device: Optional[pulumi.Input[str]] = None,
                 system_metadata_device: Optional[pulumi.Input[str]] = None,
                 use_all: Optional[pulumi.Input[bool]] = None,
                 use_all_with_partitions: Optional[pulumi.Input[bool]] = None):
        """
        Details of the storage used by the storage driver.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: List of devices to be used by the storage driver.
        :param pulumi.Input[bool] force_use_disks: Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        :param pulumi.Input[str] journal_device: Device used for journaling.
        :param pulumi.Input[str] kvdb_device: Device used for internal KVDB.
        :param pulumi.Input[str] system_metadata_device: Device that will be used to store system metadata by the driver.
        :param pulumi.Input[bool] use_all: Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        :param pulumi.Input[bool] use_all_with_partitions: Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if force_use_disks is not None:
            pulumi.set(__self__, "force_use_disks", force_use_disks)
        if journal_device is not None:
            pulumi.set(__self__, "journal_device", journal_device)
        if kvdb_device is not None:
            pulumi.set(__self__, "kvdb_device", kvdb_device)
        if system_metadata_device is not None:
            pulumi.set(__self__, "system_metadata_device", system_metadata_device)
        if use_all is not None:
            pulumi.set(__self__, "use_all", use_all)
        if use_all_with_partitions is not None:
            pulumi.set(__self__, "use_all_with_partitions", use_all_with_partitions)

    @property
    @pulumi.getter
    def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of devices to be used by the storage driver.
        """
        return pulumi.get(self, "devices")

    @devices.setter
    def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "devices", value)

    @property
    @pulumi.getter(name="forceUseDisks")
    def force_use_disks(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        """
        return pulumi.get(self, "force_use_disks")

    @force_use_disks.setter
    def force_use_disks(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force_use_disks", value)

    @property
    @pulumi.getter(name="journalDevice")
    def journal_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for journaling.
        """
        return pulumi.get(self, "journal_device")

    @journal_device.setter
    def journal_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "journal_device", value)

    @property
    @pulumi.getter(name="kvdbDevice")
    def kvdb_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for internal KVDB.
        """
        return pulumi.get(self, "kvdb_device")

    @kvdb_device.setter
    def kvdb_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvdb_device", value)

    @property
    @pulumi.getter(name="systemMetadataDevice")
    def system_metadata_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device that will be used to store system metadata by the driver.
        """
        return pulumi.get(self, "system_metadata_device")

    @system_metadata_device.setter
    def system_metadata_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "system_metadata_device", value)

    @property
    @pulumi.getter(name="useAll")
    def use_all(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all")

    @use_all.setter
    def use_all(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all", value)

    @property
    @pulumi.getter(name="useAllWithPartitions")
    def use_all_with_partitions(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all_with_partitions")

    @use_all_with_partitions.setter
    def use_all_with_partitions(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all_with_partitions", value)


@pulumi.input_type
class StorageClusterSpecStorkArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 lock_image: Optional[pulumi.Input[bool]] = None):
        """
        Contains STORK related spec.
        :param pulumi.Input[Mapping[str, Any]] args: It is map of arguments given to STORK. Example: driver: pxd
        :param pulumi.Input[bool] enabled: Flag indicating whether STORK needs to be enabled.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]] env: List of environment variables used by STORK. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[str] image: Docker image of the STORK container.
        :param pulumi.Input[bool] lock_image: Flag indicating if the STORK image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if lock_image is not None:
            pulumi.set(__self__, "lock_image", lock_image)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        It is map of arguments given to STORK. Example: driver: pxd
        """
        return pulumi.get(self, "args")

    @args.setter
    def args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "args", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether STORK needs to be enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]]]:
        """
        List of environment variables used by STORK. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the STORK container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="lockImage")
    def lock_image(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating if the STORK image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        return pulumi.get(self, "lock_image")

    @lock_image.setter
    def lock_image(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lock_image", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs']] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        An update strategy to replace existing StorageCluster pods with new pods.
        :param pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs'] rolling_update: Spec to control the desired behavior of storage cluster rolling update.
        :param pulumi.Input[str] type: Type of storage cluster update. Can be RollingUpdate or OnDelete. Default is RollingUpdate.
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional[pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs']]:
        """
        Spec to control the desired behavior of storage cluster rolling update.
        """
        return pulumi.get(self, "rolling_update")

    @rolling_update.setter
    def rolling_update(self, value: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs']]):
        pulumi.set(self, "rolling_update", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of storage cluster update. Can be RollingUpdate or OnDelete. Default is RollingUpdate.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterSpecUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_unavailable: Optional[pulumi.Input[Union[int, str]]] = None):
        """
        Spec to control the desired behavior of storage cluster rolling update.
        :param pulumi.Input[Union[int, str]] max_unavailable: The maximum number of StorageCluster pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of StorageCluster pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the storage pod can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those StorageCluster pods and then brings up new StorageCluster pods in their place. Once the new pods are available, it then proceeds onto other StorageCluster pods, thus ensuring that at least 70% of original number of StorageCluster pods are available at all times during the update.
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[Union[int, str]]]:
        """
        The maximum number of StorageCluster pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of StorageCluster pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the storage pod can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those StorageCluster pods and then brings up new StorageCluster pods in their place. Once the new pods are available, it then proceeds onto other StorageCluster pods, thus ensuring that at least 70% of original number of StorageCluster pods are available at all times during the update.
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[Union[int, str]]]):
        pulumi.set(self, "max_unavailable", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 lock_image: Optional[pulumi.Input[bool]] = None):
        """
        Contains spec of a user interface for the storage driver.
        :param pulumi.Input[bool] enabled: Flag indicating whether the user interface needs to be enabled.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]] env: List of environment variables used by the UI components. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[str] image: Docker image of the user interface container.
        :param pulumi.Input[bool] lock_image: Flag indicating if the user interface image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if lock_image is not None:
            pulumi.set(__self__, "lock_image", lock_image)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether the user interface needs to be enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]]]:
        """
        List of environment variables used by the UI components. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the user interface container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="lockImage")
    def lock_image(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating if the user interface image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        return pulumi.get(self, "lock_image")

    @lock_image.setter
    def lock_image(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lock_image", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterStatusArgs:
    def __init__(__self__, *,
                 cluster_name: Optional[pulumi.Input[str]] = None,
                 cluster_uid: Optional[pulumi.Input[str]] = None,
                 collision_count: Optional[pulumi.Input[int]] = None,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]]] = None,
                 phase: Optional[pulumi.Input[str]] = None,
                 storage: Optional[pulumi.Input['StorageClusterStatusStorageArgs']] = None):
        """
        Most recently observed status of the storage cluster. This data may not be up to date.
        :param pulumi.Input[str] cluster_name: Name of the storage cluster.
        :param pulumi.Input[str] cluster_uid: Unique ID of the storage cluster.
        :param pulumi.Input[int] collision_count: Count of hash collisions for the StorageCluster. The StorageCluster controller uses this field as a collision avoidance mechanism when it needs to create the name of the newest ControllerRevision.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]] conditions: Contains details for the current condition of this cluster.
        :param pulumi.Input[str] phase: Phase of the StorageCluster is a simple, high-level summary of where the StorageCluster is in its lifecycle. The condition array contains more detailed information about the state of the cluster.
        :param pulumi.Input['StorageClusterStatusStorageArgs'] storage: Contains details of storage in the cluster.
        """
        if cluster_name is not None:
            pulumi.set(__self__, "cluster_name", cluster_name)
        if cluster_uid is not None:
            pulumi.set(__self__, "cluster_uid", cluster_uid)
        if collision_count is not None:
            pulumi.set(__self__, "collision_count", collision_count)
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)
        if storage is not None:
            pulumi.set(__self__, "storage", storage)

    @property
    @pulumi.getter(name="clusterName")
    def cluster_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the storage cluster.
        """
        return pulumi.get(self, "cluster_name")

    @cluster_name.setter
    def cluster_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_name", value)

    @property
    @pulumi.getter(name="clusterUid")
    def cluster_uid(self) -> Optional[pulumi.Input[str]]:
        """
        Unique ID of the storage cluster.
        """
        return pulumi.get(self, "cluster_uid")

    @cluster_uid.setter
    def cluster_uid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_uid", value)

    @property
    @pulumi.getter(name="collisionCount")
    def collision_count(self) -> Optional[pulumi.Input[int]]:
        """
        Count of hash collisions for the StorageCluster. The StorageCluster controller uses this field as a collision avoidance mechanism when it needs to create the name of the newest ControllerRevision.
        """
        return pulumi.get(self, "collision_count")

    @collision_count.setter
    def collision_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "collision_count", value)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]]]:
        """
        Contains details for the current condition of this cluster.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[str]]:
        """
        Phase of the StorageCluster is a simple, high-level summary of where the StorageCluster is in its lifecycle. The condition array contains more detailed information about the state of the cluster.
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "phase", value)

    @property
    @pulumi.getter
    def storage(self) -> Optional[pulumi.Input['StorageClusterStatusStorageArgs']]:
        """
        Contains details of storage in the cluster.
        """
        return pulumi.get(self, "storage")

    @storage.setter
    def storage(self, value: Optional[pulumi.Input['StorageClusterStatusStorageArgs']]):
        pulumi.set(self, "storage", value)


@pulumi.input_type
class StorageClusterStatusConditionsArgs:
    def __init__(__self__, *,
                 reason: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] reason: Reason is human readable message indicating details about the current state of the cluster.
        :param pulumi.Input[str] status: Status of the condition.
        :param pulumi.Input[str] type: Type of the condition.
        """
        if reason is not None:
            pulumi.set(__self__, "reason", reason)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def reason(self) -> Optional[pulumi.Input[str]]:
        """
        Reason is human readable message indicating details about the current state of the cluster.
        """
        return pulumi.get(self, "reason")

    @reason.setter
    def reason(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "reason", value)

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        Status of the condition.
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "status", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the condition.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterStatusStorageArgs:
    def __init__(__self__, *,
                 storage_nodes_per_zone: Optional[pulumi.Input[int]] = None):
        """
        Contains details of storage in the cluster.
        :param pulumi.Input[int] storage_nodes_per_zone: The number of storage nodes per zone in the cluster.
        """
        if storage_nodes_per_zone is not None:
            pulumi.set(__self__, "storage_nodes_per_zone", storage_nodes_per_zone)

    @property
    @pulumi.getter(name="storageNodesPerZone")
    def storage_nodes_per_zone(self) -> Optional[pulumi.Input[int]]:
        """
        The number of storage nodes per zone in the cluster.
        """
        return pulumi.get(self, "storage_nodes_per_zone")

    @storage_nodes_per_zone.setter
    def storage_nodes_per_zone(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "storage_nodes_per_zone", value)


@pulumi.input_type
class StorageNodeSpecArgs:
    def __init__(__self__, *,
                 cloud_storage: Optional[pulumi.Input['StorageNodeSpecCloudStorageArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        The desired behavior of the storage node. Currently changing the spec does not affect the actual storage node in the cluster. Eventually spec in StorageNode will override the spec from StorageCluster so that configuration can be overridden at node level.
        :param pulumi.Input['StorageNodeSpecCloudStorageArgs'] cloud_storage: Details of storage on the node for cloud environments.
        :param pulumi.Input[str] version: Version of the storage driver on the node.
        """
        if cloud_storage is not None:
            pulumi.set(__self__, "cloud_storage", cloud_storage)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="cloudStorage")
    def cloud_storage(self) -> Optional[pulumi.Input['StorageNodeSpecCloudStorageArgs']]:
        """
        Details of storage on the node for cloud environments.
        """
        return pulumi.get(self, "cloud_storage")

    @cloud_storage.setter
    def cloud_storage(self, value: Optional[pulumi.Input['StorageNodeSpecCloudStorageArgs']]):
        pulumi.set(self, "cloud_storage", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        Version of the storage driver on the node.
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class StorageNodeSpecCloudStorageArgs:
    def __init__(__self__, *,
                 drive_configs: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]]] = None):
        """
        Details of storage on the node for cloud environments.
        :param pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]] drive_configs: List of cloud drive configs for the storage node.
        """
        if drive_configs is not None:
            pulumi.set(__self__, "drive_configs", drive_configs)

    @property
    @pulumi.getter(name="driveConfigs")
    def drive_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]]]:
        """
        List of cloud drive configs for the storage node.
        """
        return pulumi.get(self, "drive_configs")

    @drive_configs.setter
    def drive_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]]]):
        pulumi.set(self, "drive_configs", value)


@pulumi.input_type
class StorageNodeSpecCloudStorageDriveConfigsArgs:
    def __init__(__self__, *,
                 iops: Optional[pulumi.Input[int]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 size_in_gi_b: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] iops: IOPS required from the cloud drive.
        :param pulumi.Input[Mapping[str, Any]] options: Additional options for the cloud drive.
        :param pulumi.Input[int] size_in_gi_b: Size of cloud drive in GiB.
        :param pulumi.Input[str] type: Type of cloud drive.
        """
        if iops is not None:
            pulumi.set(__self__, "iops", iops)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if size_in_gi_b is not None:
            pulumi.set(__self__, "size_in_gi_b", size_in_gi_b)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def iops(self) -> Optional[pulumi.Input[int]]:
        """
        IOPS required from the cloud drive.
        """
        return pulumi.get(self, "iops")

    @iops.setter
    def iops(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "iops", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Additional options for the cloud drive.
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter(name="sizeInGiB")
    def size_in_gi_b(self) -> Optional[pulumi.Input[int]]:
        """
        Size of cloud drive in GiB.
        """
        return pulumi.get(self, "size_in_gi_b")

    @size_in_gi_b.setter
    def size_in_gi_b(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size_in_gi_b", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of cloud drive.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageNodeStatusArgs:
    def __init__(__self__, *,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]]] = None,
                 geography: Optional[pulumi.Input['StorageNodeStatusGeographyArgs']] = None,
                 network: Optional[pulumi.Input['StorageNodeStatusNetworkArgs']] = None,
                 node_uid: Optional[pulumi.Input[str]] = None,
                 phase: Optional[pulumi.Input[str]] = None):
        """
        Most recently observed status of the storage node. The data may not be up to date.
        :param pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]] conditions: Contains details for the current condition of this storage node.
        :param pulumi.Input['StorageNodeStatusGeographyArgs'] geography: Contains topology information for the storage node.
        :param pulumi.Input[str] node_uid: Unique ID of the storage node.
        :param pulumi.Input[str] phase: Phase of the StorageNode is a simple, high-level summary of where the StorageNode is in its lifecycle. The condition array contains more detailed information about the state of the node.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if geography is not None:
            pulumi.set(__self__, "geography", geography)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if node_uid is not None:
            pulumi.set(__self__, "node_uid", node_uid)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]]]:
        """
        Contains details for the current condition of this storage node.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def geography(self) -> Optional[pulumi.Input['StorageNodeStatusGeographyArgs']]:
        """
        Contains topology information for the storage node.
        """
        return pulumi.get(self, "geography")

    @geography.setter
    def geography(self, value: Optional[pulumi.Input['StorageNodeStatusGeographyArgs']]):
        pulumi.set(self, "geography", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['StorageNodeStatusNetworkArgs']]:
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['StorageNodeStatusNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="nodeUid")
    def node_uid(self) -> Optional[pulumi.Input[str]]:
        """
        Unique ID of the storage node.
        """
        return pulumi.get(self, "node_uid")

    @node_uid.setter
    def node_uid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_uid", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[str]]:
        """
        Phase of the StorageNode is a simple, high-level summary of where the StorageNode is in its lifecycle. The condition array contains more detailed information about the state of the node.
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "phase", value)


@pulumi.input_type
class StorageNodeStatusConditionsArgs:
    def __init__(__self__, *,
                 reason: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] reason: Reason is the human readable message indicating details about the current state of the cluster.
        :param pulumi.Input[str] status: Status of the condition.
        :param pulumi.Input[str] type: Type of the condition.
        """
        if reason is not None:
            pulumi.set(__self__, "reason", reason)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def reason(self) -> Optional[pulumi.Input[str]]:
        """
        Reason is the human readable message indicating details about the current state of the cluster.
        """
        return pulumi.get(self, "reason")

    @reason.setter
    def reason(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "reason", value)

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        Status of the condition.
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "status", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the condition.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageNodeStatusGeographyArgs:
    def __init__(__self__, *,
                 rack: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        """
        Contains topology information for the storage node.
        :param pulumi.Input[str] rack: Rack on which the storage node is placed.
        :param pulumi.Input[str] region: Region in which the storage node is placed.
        :param pulumi.Input[str] zone: Zone in which the storage node is placed.
        """
        if rack is not None:
            pulumi.set(__self__, "rack", rack)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter
    def rack(self) -> Optional[pulumi.Input[str]]:
        """
        Rack on which the storage node is placed.
        """
        return pulumi.get(self, "rack")

    @rack.setter
    def rack(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rack", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        Region in which the storage node is placed.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter
    def zone(self) -> Optional[pulumi.Input[str]]:
        """
        Zone in which the storage node is placed.
        """
        return pulumi.get(self, "zone")

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


@pulumi.input_type
class StorageNodeStatusNetworkArgs:
    def __init__(__self__, *,
                 data_ip: Optional[pulumi.Input[str]] = None,
                 mgmt_ip: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] data_ip: IP address used by the storage driver for data traffic.
        :param pulumi.Input[str] mgmt_ip: IP address used by the storage driver for management traffic.
        """
        if data_ip is not None:
            pulumi.set(__self__, "data_ip", data_ip)
        if mgmt_ip is not None:
            pulumi.set(__self__, "mgmt_ip", mgmt_ip)

    @property
    @pulumi.getter(name="dataIP")
    def data_ip(self) -> Optional[pulumi.Input[str]]:
        """
        IP address used by the storage driver for data traffic.
        """
        return pulumi.get(self, "data_ip")

    @data_ip.setter
    def data_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_ip", value)

    @property
    @pulumi.getter(name="mgmtIP")
    def mgmt_ip(self) -> Optional[pulumi.Input[str]]:
        """
        IP address used by the storage driver for management traffic.
        """
        return pulumi.get(self, "mgmt_ip")

    @mgmt_ip.setter
    def mgmt_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mgmt_ip", value)



# coding=utf-8
# *** WARNING: this file was generated by crd2pulumi. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables

__all__ = [
    'StorageClusterSpecArgs',
    'StorageClusterSpecAutopilotArgs',
    'StorageClusterSpecAutopilotEnvArgs',
    'StorageClusterSpecAutopilotEnvValueFromArgs',
    'StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecAutopilotEnvValueFromFieldRefArgs',
    'StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecAutopilotProvidersArgs',
    'StorageClusterSpecCloudStorageArgs',
    'StorageClusterSpecCloudStorageCapacitySpecsArgs',
    'StorageClusterSpecDeleteStrategyArgs',
    'StorageClusterSpecEnvArgs',
    'StorageClusterSpecEnvValueFromArgs',
    'StorageClusterSpecEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecEnvValueFromFieldRefArgs',
    'StorageClusterSpecEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecKvdbArgs',
    'StorageClusterSpecMonitoringArgs',
    'StorageClusterSpecMonitoringPrometheusArgs',
    'StorageClusterSpecNetworkArgs',
    'StorageClusterSpecNodesArgs',
    'StorageClusterSpecNodesEnvArgs',
    'StorageClusterSpecNodesEnvValueFromArgs',
    'StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecNodesEnvValueFromFieldRefArgs',
    'StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecNodesNetworkArgs',
    'StorageClusterSpecNodesSelectorArgs',
    'StorageClusterSpecNodesSelectorLabelSelectorArgs',
    'StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs',
    'StorageClusterSpecNodesStorageArgs',
    'StorageClusterSpecPlacementArgs',
    'StorageClusterSpecPlacementNodeAffinityArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs',
    'StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs',
    'StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs',
    'StorageClusterSpecPlacementTolerationsArgs',
    'StorageClusterSpecStorageArgs',
    'StorageClusterSpecStorkArgs',
    'StorageClusterSpecStorkEnvArgs',
    'StorageClusterSpecStorkEnvValueFromArgs',
    'StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecStorkEnvValueFromFieldRefArgs',
    'StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs',
    'StorageClusterSpecUpdateStrategyArgs',
    'StorageClusterSpecUpdateStrategyRollingUpdateArgs',
    'StorageClusterSpecUserInterfaceArgs',
    'StorageClusterSpecUserInterfaceEnvArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs',
    'StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs',
    'StorageClusterStatusArgs',
    'StorageClusterStatusConditionsArgs',
    'StorageClusterStatusStorageArgs',
    'StorageNodeSpecArgs',
    'StorageNodeSpecCloudStorageArgs',
    'StorageNodeSpecCloudStorageDriveConfigsArgs',
    'StorageNodeStatusArgs',
    'StorageNodeStatusConditionsArgs',
    'StorageNodeStatusGeographyArgs',
    'StorageNodeStatusNetworkArgs',
]

@pulumi.input_type
class StorageClusterSpecArgs:
    def __init__(__self__, *,
                 autopilot: Optional[pulumi.Input['StorageClusterSpecAutopilotArgs']] = None,
                 cloud_storage: Optional[pulumi.Input['StorageClusterSpecCloudStorageArgs']] = None,
                 custom_image_registry: Optional[pulumi.Input[str]] = None,
                 delete_strategy: Optional[pulumi.Input['StorageClusterSpecDeleteStrategyArgs']] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]]] = None,
                 feature_gates: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 image_pull_policy: Optional[pulumi.Input[str]] = None,
                 image_pull_secret: Optional[pulumi.Input[str]] = None,
                 kvdb: Optional[pulumi.Input['StorageClusterSpecKvdbArgs']] = None,
                 monitoring: Optional[pulumi.Input['StorageClusterSpecMonitoringArgs']] = None,
                 network: Optional[pulumi.Input['StorageClusterSpecNetworkArgs']] = None,
                 nodes: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]]] = None,
                 placement: Optional[pulumi.Input['StorageClusterSpecPlacementArgs']] = None,
                 revision_history_limit: Optional[pulumi.Input[int]] = None,
                 runtime_options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 secrets_provider: Optional[pulumi.Input[str]] = None,
                 start_port: Optional[pulumi.Input[int]] = None,
                 storage: Optional[pulumi.Input['StorageClusterSpecStorageArgs']] = None,
                 stork: Optional[pulumi.Input['StorageClusterSpecStorkArgs']] = None,
                 update_strategy: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyArgs']] = None,
                 user_interface: Optional[pulumi.Input['StorageClusterSpecUserInterfaceArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        The desired behavior of the storage cluster.
        :param pulumi.Input['StorageClusterSpecAutopilotArgs'] autopilot: Contains spec of autopilot component for storage driver.
        :param pulumi.Input['StorageClusterSpecCloudStorageArgs'] cloud_storage: Details of storage used in cloud environment.
        :param pulumi.Input[str] custom_image_registry: Custom container image registry server that will be used instead of index.docker.io to download Docker images. This may include the repository as well. (Example: myregistry.net:5443 or myregistry.com/myrepository)
        :param pulumi.Input['StorageClusterSpecDeleteStrategyArgs'] delete_strategy: Delete strategy to uninstall and wipe the storage cluster.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]] env: List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[Mapping[str, Any]] feature_gates: This is a map of feature names to string values.
        :param pulumi.Input[str] image: Docker image of the storage driver.
        :param pulumi.Input[str] image_pull_policy: Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always.
        :param pulumi.Input[str] image_pull_secret: Image pull secret is a reference to secret in the same namespace as the StorageCluster. It is used for pulling all images used by the StorageCluster.
        :param pulumi.Input['StorageClusterSpecKvdbArgs'] kvdb: Details of KVDB that the storage driver will use.
        :param pulumi.Input['StorageClusterSpecMonitoringArgs'] monitoring: Contains monitoring configuration for the storage cluster.
        :param pulumi.Input['StorageClusterSpecNetworkArgs'] network: Contains network information that is needed by the storage driver.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]] nodes: Node level configurations that will override the configuration at cluster level. These configurations can be for individual nodes or can be grouped to override configuration of multiple nodes based on label selectors.
        :param pulumi.Input['StorageClusterSpecPlacementArgs'] placement: Describes placement configuration for the storage cluster pods.
        :param pulumi.Input[int] revision_history_limit: The number of old history to retain to allow rollback. This is a pointer to distinguish between an explicit zero and not specified. Defaults to 10.
        :param pulumi.Input[Mapping[str, Any]] runtime_options: This is map of any runtime options that need to be sent to the storage driver. The value is a string.
        :param pulumi.Input[str] secrets_provider: Secrets provider is the name of secret provider that driver will connect to.
        :param pulumi.Input[int] start_port: Start port is the starting port in the range of ports used by the cluster.
        :param pulumi.Input['StorageClusterSpecStorageArgs'] storage: Details of the storage used by the storage driver.
        :param pulumi.Input['StorageClusterSpecStorkArgs'] stork: Contains STORK related spec.
        :param pulumi.Input['StorageClusterSpecUpdateStrategyArgs'] update_strategy: An update strategy to replace existing StorageCluster pods with new pods.
        :param pulumi.Input['StorageClusterSpecUserInterfaceArgs'] user_interface: Contains spec of a user interface for the storage driver.
        :param pulumi.Input[str] version: Version of the storage driver. This field is read-only.
        """
        if autopilot is not None:
            pulumi.set(__self__, "autopilot", autopilot)
        if cloud_storage is not None:
            pulumi.set(__self__, "cloud_storage", cloud_storage)
        if custom_image_registry is not None:
            pulumi.set(__self__, "custom_image_registry", custom_image_registry)
        if delete_strategy is not None:
            pulumi.set(__self__, "delete_strategy", delete_strategy)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if feature_gates is not None:
            pulumi.set(__self__, "feature_gates", feature_gates)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if kvdb is not None:
            pulumi.set(__self__, "kvdb", kvdb)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if placement is not None:
            pulumi.set(__self__, "placement", placement)
        if revision_history_limit is not None:
            pulumi.set(__self__, "revision_history_limit", revision_history_limit)
        if runtime_options is not None:
            pulumi.set(__self__, "runtime_options", runtime_options)
        if secrets_provider is not None:
            pulumi.set(__self__, "secrets_provider", secrets_provider)
        if start_port is not None:
            pulumi.set(__self__, "start_port", start_port)
        if storage is not None:
            pulumi.set(__self__, "storage", storage)
        if stork is not None:
            pulumi.set(__self__, "stork", stork)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if user_interface is not None:
            pulumi.set(__self__, "user_interface", user_interface)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def autopilot(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotArgs']]:
        """
        Contains spec of autopilot component for storage driver.
        """
        return pulumi.get(self, "autopilot")

    @autopilot.setter
    def autopilot(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotArgs']]):
        pulumi.set(self, "autopilot", value)

    @property
    @pulumi.getter(name="cloudStorage")
    def cloud_storage(self) -> Optional[pulumi.Input['StorageClusterSpecCloudStorageArgs']]:
        """
        Details of storage used in cloud environment.
        """
        return pulumi.get(self, "cloud_storage")

    @cloud_storage.setter
    def cloud_storage(self, value: Optional[pulumi.Input['StorageClusterSpecCloudStorageArgs']]):
        pulumi.set(self, "cloud_storage", value)

    @property
    @pulumi.getter(name="customImageRegistry")
    def custom_image_registry(self) -> Optional[pulumi.Input[str]]:
        """
        Custom container image registry server that will be used instead of index.docker.io to download Docker images. This may include the repository as well. (Example: myregistry.net:5443 or myregistry.com/myrepository)
        """
        return pulumi.get(self, "custom_image_registry")

    @custom_image_registry.setter
    def custom_image_registry(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_image_registry", value)

    @property
    @pulumi.getter(name="deleteStrategy")
    def delete_strategy(self) -> Optional[pulumi.Input['StorageClusterSpecDeleteStrategyArgs']]:
        """
        Delete strategy to uninstall and wipe the storage cluster.
        """
        return pulumi.get(self, "delete_strategy")

    @delete_strategy.setter
    def delete_strategy(self, value: Optional[pulumi.Input['StorageClusterSpecDeleteStrategyArgs']]):
        pulumi.set(self, "delete_strategy", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]]]:
        """
        List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter(name="featureGates")
    def feature_gates(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        This is a map of feature names to string values.
        """
        return pulumi.get(self, "feature_gates")

    @feature_gates.setter
    def feature_gates(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "feature_gates", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the storage driver.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always.
        """
        return pulumi.get(self, "image_pull_policy")

    @image_pull_policy.setter
    def image_pull_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_pull_policy", value)

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[pulumi.Input[str]]:
        """
        Image pull secret is a reference to secret in the same namespace as the StorageCluster. It is used for pulling all images used by the StorageCluster.
        """
        return pulumi.get(self, "image_pull_secret")

    @image_pull_secret.setter
    def image_pull_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_pull_secret", value)

    @property
    @pulumi.getter
    def kvdb(self) -> Optional[pulumi.Input['StorageClusterSpecKvdbArgs']]:
        """
        Details of KVDB that the storage driver will use.
        """
        return pulumi.get(self, "kvdb")

    @kvdb.setter
    def kvdb(self, value: Optional[pulumi.Input['StorageClusterSpecKvdbArgs']]):
        pulumi.set(self, "kvdb", value)

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input['StorageClusterSpecMonitoringArgs']]:
        """
        Contains monitoring configuration for the storage cluster.
        """
        return pulumi.get(self, "monitoring")

    @monitoring.setter
    def monitoring(self, value: Optional[pulumi.Input['StorageClusterSpecMonitoringArgs']]):
        pulumi.set(self, "monitoring", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['StorageClusterSpecNetworkArgs']]:
        """
        Contains network information that is needed by the storage driver.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['StorageClusterSpecNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter
    def nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]]]:
        """
        Node level configurations that will override the configuration at cluster level. These configurations can be for individual nodes or can be grouped to override configuration of multiple nodes based on label selectors.
        """
        return pulumi.get(self, "nodes")

    @nodes.setter
    def nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]]]):
        pulumi.set(self, "nodes", value)

    @property
    @pulumi.getter
    def placement(self) -> Optional[pulumi.Input['StorageClusterSpecPlacementArgs']]:
        """
        Describes placement configuration for the storage cluster pods.
        """
        return pulumi.get(self, "placement")

    @placement.setter
    def placement(self, value: Optional[pulumi.Input['StorageClusterSpecPlacementArgs']]):
        pulumi.set(self, "placement", value)

    @property
    @pulumi.getter(name="revisionHistoryLimit")
    def revision_history_limit(self) -> Optional[pulumi.Input[int]]:
        """
        The number of old history to retain to allow rollback. This is a pointer to distinguish between an explicit zero and not specified. Defaults to 10.
        """
        return pulumi.get(self, "revision_history_limit")

    @revision_history_limit.setter
    def revision_history_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "revision_history_limit", value)

    @property
    @pulumi.getter(name="runtimeOptions")
    def runtime_options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        This is map of any runtime options that need to be sent to the storage driver. The value is a string.
        """
        return pulumi.get(self, "runtime_options")

    @runtime_options.setter
    def runtime_options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "runtime_options", value)

    @property
    @pulumi.getter(name="secretsProvider")
    def secrets_provider(self) -> Optional[pulumi.Input[str]]:
        """
        Secrets provider is the name of secret provider that driver will connect to.
        """
        return pulumi.get(self, "secrets_provider")

    @secrets_provider.setter
    def secrets_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secrets_provider", value)

    @property
    @pulumi.getter(name="startPort")
    def start_port(self) -> Optional[pulumi.Input[int]]:
        """
        Start port is the starting port in the range of ports used by the cluster.
        """
        return pulumi.get(self, "start_port")

    @start_port.setter
    def start_port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "start_port", value)

    @property
    @pulumi.getter
    def storage(self) -> Optional[pulumi.Input['StorageClusterSpecStorageArgs']]:
        """
        Details of the storage used by the storage driver.
        """
        return pulumi.get(self, "storage")

    @storage.setter
    def storage(self, value: Optional[pulumi.Input['StorageClusterSpecStorageArgs']]):
        pulumi.set(self, "storage", value)

    @property
    @pulumi.getter
    def stork(self) -> Optional[pulumi.Input['StorageClusterSpecStorkArgs']]:
        """
        Contains STORK related spec.
        """
        return pulumi.get(self, "stork")

    @stork.setter
    def stork(self, value: Optional[pulumi.Input['StorageClusterSpecStorkArgs']]):
        pulumi.set(self, "stork", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['StorageClusterSpecUpdateStrategyArgs']]:
        """
        An update strategy to replace existing StorageCluster pods with new pods.
        """
        return pulumi.get(self, "update_strategy")

    @update_strategy.setter
    def update_strategy(self, value: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyArgs']]):
        pulumi.set(self, "update_strategy", value)

    @property
    @pulumi.getter(name="userInterface")
    def user_interface(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceArgs']]:
        """
        Contains spec of a user interface for the storage driver.
        """
        return pulumi.get(self, "user_interface")

    @user_interface.setter
    def user_interface(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceArgs']]):
        pulumi.set(self, "user_interface", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        Version of the storage driver. This field is read-only.
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class StorageClusterSpecAutopilotArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 lock_image: Optional[pulumi.Input[bool]] = None,
                 providers: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]]] = None):
        """
        Contains spec of autopilot component for storage driver.
        :param pulumi.Input[Mapping[str, Any]] args: It is a map of arguments provided to autopilot. Example: log-level: debug
        :param pulumi.Input[bool] enabled: Flag indicating whether autopilot needs to be enabled.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]] env: List of environment variables used by autopilot. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[str] image: Docker image of the autopilot container.
        :param pulumi.Input[bool] lock_image: Flag indicating if the autopilot image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]] providers: List of input data providers to autopilot.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if lock_image is not None:
            pulumi.set(__self__, "lock_image", lock_image)
        if providers is not None:
            pulumi.set(__self__, "providers", providers)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        It is a map of arguments provided to autopilot. Example: log-level: debug
        """
        return pulumi.get(self, "args")

    @args.setter
    def args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "args", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether autopilot needs to be enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]]]:
        """
        List of environment variables used by autopilot. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the autopilot container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="lockImage")
    def lock_image(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating if the autopilot image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        return pulumi.get(self, "lock_image")

    @lock_image.setter
    def lock_image(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lock_image", value)

    @property
    @pulumi.getter
    def providers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]]]:
        """
        List of input data providers to autopilot.
        """
        return pulumi.get(self, "providers")

    @providers.setter
    def providers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]]]):
        pulumi.set(self, "providers", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecAutopilotEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecAutopilotProvidersArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 params: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: Unique name of the data provider.
        :param pulumi.Input[Mapping[str, Any]] params: Map of key-value params for the provider.
        :param pulumi.Input[str] type: Type of the data provider. For instance - prometheus
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if params is not None:
            pulumi.set(__self__, "params", params)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Unique name of the data provider.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Map of key-value params for the provider.
        """
        return pulumi.get(self, "params")

    @params.setter
    def params(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "params", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the data provider. For instance - prometheus
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterSpecCloudStorageArgs:
    def __init__(__self__, *,
                 capacity_specs: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]]] = None,
                 device_specs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 journal_device_spec: Optional[pulumi.Input[str]] = None,
                 kvdb_device_spec: Optional[pulumi.Input[str]] = None,
                 max_storage_nodes: Optional[pulumi.Input[int]] = None,
                 max_storage_nodes_per_zone: Optional[pulumi.Input[int]] = None,
                 system_metadata_device_spec: Optional[pulumi.Input[str]] = None):
        """
        Details of storage used in cloud environment.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]] capacity_specs: List of cluster wide storage types and their capacities. A single capacity spec identifies a storage pool with a set of minimum requested IOPS and size. Based on the cloud provider, the total storage capacity will get divided amongst the nodes. The nodes bearing storage themselves will get uniformly distributed across all the zones.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] device_specs: List of storage device specs. A cloud storage device will be created for every spec in the list. The specs will be applied to all nodes in the cluster up to spec.cloudStorage.maxStorageNodes or spec.cloudStorage.maxStorageNodesPerZone. This will be ignored if spec.cloudStorage.capacitySpecs is present.
        :param pulumi.Input[str] journal_device_spec: Device spec for the journal device.
        :param pulumi.Input[str] kvdb_device_spec: Device spec for internal KVDB device.
        :param pulumi.Input[int] max_storage_nodes: Maximum nodes that will have storage in the cluster.
        :param pulumi.Input[int] max_storage_nodes_per_zone: Maximum nodes in every zone that will have storage in the cluster.
        :param pulumi.Input[str] system_metadata_device_spec: Device spec for the metadata device. This device will be used to store system metadata by the driver.
        """
        if capacity_specs is not None:
            pulumi.set(__self__, "capacity_specs", capacity_specs)
        if device_specs is not None:
            pulumi.set(__self__, "device_specs", device_specs)
        if journal_device_spec is not None:
            pulumi.set(__self__, "journal_device_spec", journal_device_spec)
        if kvdb_device_spec is not None:
            pulumi.set(__self__, "kvdb_device_spec", kvdb_device_spec)
        if max_storage_nodes is not None:
            pulumi.set(__self__, "max_storage_nodes", max_storage_nodes)
        if max_storage_nodes_per_zone is not None:
            pulumi.set(__self__, "max_storage_nodes_per_zone", max_storage_nodes_per_zone)
        if system_metadata_device_spec is not None:
            pulumi.set(__self__, "system_metadata_device_spec", system_metadata_device_spec)

    @property
    @pulumi.getter(name="capacitySpecs")
    def capacity_specs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]]]:
        """
        List of cluster wide storage types and their capacities. A single capacity spec identifies a storage pool with a set of minimum requested IOPS and size. Based on the cloud provider, the total storage capacity will get divided amongst the nodes. The nodes bearing storage themselves will get uniformly distributed across all the zones.
        """
        return pulumi.get(self, "capacity_specs")

    @capacity_specs.setter
    def capacity_specs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]]]):
        pulumi.set(self, "capacity_specs", value)

    @property
    @pulumi.getter(name="deviceSpecs")
    def device_specs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of storage device specs. A cloud storage device will be created for every spec in the list. The specs will be applied to all nodes in the cluster up to spec.cloudStorage.maxStorageNodes or spec.cloudStorage.maxStorageNodesPerZone. This will be ignored if spec.cloudStorage.capacitySpecs is present.
        """
        return pulumi.get(self, "device_specs")

    @device_specs.setter
    def device_specs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "device_specs", value)

    @property
    @pulumi.getter(name="journalDeviceSpec")
    def journal_device_spec(self) -> Optional[pulumi.Input[str]]:
        """
        Device spec for the journal device.
        """
        return pulumi.get(self, "journal_device_spec")

    @journal_device_spec.setter
    def journal_device_spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "journal_device_spec", value)

    @property
    @pulumi.getter(name="kvdbDeviceSpec")
    def kvdb_device_spec(self) -> Optional[pulumi.Input[str]]:
        """
        Device spec for internal KVDB device.
        """
        return pulumi.get(self, "kvdb_device_spec")

    @kvdb_device_spec.setter
    def kvdb_device_spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvdb_device_spec", value)

    @property
    @pulumi.getter(name="maxStorageNodes")
    def max_storage_nodes(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum nodes that will have storage in the cluster.
        """
        return pulumi.get(self, "max_storage_nodes")

    @max_storage_nodes.setter
    def max_storage_nodes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_storage_nodes", value)

    @property
    @pulumi.getter(name="maxStorageNodesPerZone")
    def max_storage_nodes_per_zone(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum nodes in every zone that will have storage in the cluster.
        """
        return pulumi.get(self, "max_storage_nodes_per_zone")

    @max_storage_nodes_per_zone.setter
    def max_storage_nodes_per_zone(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_storage_nodes_per_zone", value)

    @property
    @pulumi.getter(name="systemMetadataDeviceSpec")
    def system_metadata_device_spec(self) -> Optional[pulumi.Input[str]]:
        """
        Device spec for the metadata device. This device will be used to store system metadata by the driver.
        """
        return pulumi.get(self, "system_metadata_device_spec")

    @system_metadata_device_spec.setter
    def system_metadata_device_spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "system_metadata_device_spec", value)


@pulumi.input_type
class StorageClusterSpecCloudStorageCapacitySpecsArgs:
    def __init__(__self__, *,
                 max_capacity_in_gi_b: Optional[pulumi.Input[int]] = None,
                 min_capacity_in_gi_b: Optional[pulumi.Input[int]] = None,
                 min_iops: Optional[pulumi.Input[int]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[int] max_capacity_in_gi_b: Maximum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be greater than this number for the entire cluster.
        :param pulumi.Input[int] min_capacity_in_gi_b: Minimum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be less than this number for the entire cluster.
        :param pulumi.Input[int] min_iops: Minimum IOPS expected from the cloud drive.
        :param pulumi.Input[Mapping[str, Any]] options: Additional options required to provision the drive in cloud.
        """
        if max_capacity_in_gi_b is not None:
            pulumi.set(__self__, "max_capacity_in_gi_b", max_capacity_in_gi_b)
        if min_capacity_in_gi_b is not None:
            pulumi.set(__self__, "min_capacity_in_gi_b", min_capacity_in_gi_b)
        if min_iops is not None:
            pulumi.set(__self__, "min_iops", min_iops)
        if options is not None:
            pulumi.set(__self__, "options", options)

    @property
    @pulumi.getter(name="maxCapacityInGiB")
    def max_capacity_in_gi_b(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be greater than this number for the entire cluster.
        """
        return pulumi.get(self, "max_capacity_in_gi_b")

    @max_capacity_in_gi_b.setter
    def max_capacity_in_gi_b(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_capacity_in_gi_b", value)

    @property
    @pulumi.getter(name="minCapacityInGiB")
    def min_capacity_in_gi_b(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be less than this number for the entire cluster.
        """
        return pulumi.get(self, "min_capacity_in_gi_b")

    @min_capacity_in_gi_b.setter
    def min_capacity_in_gi_b(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_capacity_in_gi_b", value)

    @property
    @pulumi.getter(name="minIOPS")
    def min_iops(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum IOPS expected from the cloud drive.
        """
        return pulumi.get(self, "min_iops")

    @min_iops.setter
    def min_iops(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_iops", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Additional options required to provision the drive in cloud.
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)


@pulumi.input_type
class StorageClusterSpecDeleteStrategyArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input[str]] = None):
        """
        Delete strategy to uninstall and wipe the storage cluster.
        :param pulumi.Input[str] type: Type of storage cluster delete. Can be Uninstall or UninstallAndWipe. There is no default delete strategy. When no delete strategy only objects managed by the StorageCluster controller and owned by the StorageCluster object are deleted. The storage driver will be left in a state where it will not be managed by any object. Uninstall strategy ensures that the cluster is completely uninstalled even from the storage driver perspective. UninstallAndWipe strategy ensures that the cluster is completely uninstalled as well as the storage devices and metadata are wiped for reuse. This may result in data loss.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of storage cluster delete. Can be Uninstall or UninstallAndWipe. There is no default delete strategy. When no delete strategy only objects managed by the StorageCluster controller and owned by the StorageCluster object are deleted. The storage driver will be left in a state where it will not be managed by any object. Uninstall strategy ensures that the cluster is completely uninstalled even from the storage driver perspective. UninstallAndWipe strategy ensures that the cluster is completely uninstalled as well as the storage devices and metadata are wiped for reuse. This may result in data loss.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterSpecEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecKvdbArgs:
    def __init__(__self__, *,
                 auth_secret: Optional[pulumi.Input[str]] = None,
                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 internal: Optional[pulumi.Input[bool]] = None):
        """
        Details of KVDB that the storage driver will use.
        :param pulumi.Input[str] auth_secret: Authentication secret is the name of Kubernetes secret containing information to authenticate with the external KVDB. It could have the username/password for basic auth, certificate information or an ACL token.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] endpoints: If using external KVDB, this is the list of KVDB endpoints.
        :param pulumi.Input[bool] internal: Flag indicating whether to use internal KVDB or an external KVDB.
        """
        if auth_secret is not None:
            pulumi.set(__self__, "auth_secret", auth_secret)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if internal is not None:
            pulumi.set(__self__, "internal", internal)

    @property
    @pulumi.getter(name="authSecret")
    def auth_secret(self) -> Optional[pulumi.Input[str]]:
        """
        Authentication secret is the name of Kubernetes secret containing information to authenticate with the external KVDB. It could have the username/password for basic auth, certificate information or an ACL token.
        """
        return pulumi.get(self, "auth_secret")

    @auth_secret.setter
    def auth_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_secret", value)

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        If using external KVDB, this is the list of KVDB endpoints.
        """
        return pulumi.get(self, "endpoints")

    @endpoints.setter
    def endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "endpoints", value)

    @property
    @pulumi.getter
    def internal(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether to use internal KVDB or an external KVDB.
        """
        return pulumi.get(self, "internal")

    @internal.setter
    def internal(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "internal", value)


@pulumi.input_type
class StorageClusterSpecMonitoringArgs:
    def __init__(__self__, *,
                 enable_metrics: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs']] = None):
        """
        Contains monitoring configuration for the storage cluster.
        :param pulumi.Input[bool] enable_metrics: If this flag is enabled it will expose the storage cluster metrics to external monitoring solutions like Prometheus. DEPRECATED - use prometheus.exportMetrics instead
        :param pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs'] prometheus: Contains configuration of Prometheus to monitor the storage cluster.
        """
        if enable_metrics is not None:
            pulumi.set(__self__, "enable_metrics", enable_metrics)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter(name="enableMetrics")
    def enable_metrics(self) -> Optional[pulumi.Input[bool]]:
        """
        If this flag is enabled it will expose the storage cluster metrics to external monitoring solutions like Prometheus. DEPRECATED - use prometheus.exportMetrics instead
        """
        return pulumi.get(self, "enable_metrics")

    @enable_metrics.setter
    def enable_metrics(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_metrics", value)

    @property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs']]:
        """
        Contains configuration of Prometheus to monitor the storage cluster.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs']]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class StorageClusterSpecMonitoringPrometheusArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 export_metrics: Optional[pulumi.Input[bool]] = None,
                 remote_write_endpoint: Optional[pulumi.Input[str]] = None):
        """
        Contains configuration of Prometheus to monitor the storage cluster.
        :param pulumi.Input[bool] enabled: Flag indicating whether Prometheus stack needs to be enabled and deployed by the Storage operator.
        :param pulumi.Input[bool] export_metrics: If this flag is enabled it will expose the storage cluster metrics to Prometheus.
        :param pulumi.Input[str] remote_write_endpoint: Specifies the remote write endpoint for Prometheus.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if export_metrics is not None:
            pulumi.set(__self__, "export_metrics", export_metrics)
        if remote_write_endpoint is not None:
            pulumi.set(__self__, "remote_write_endpoint", remote_write_endpoint)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether Prometheus stack needs to be enabled and deployed by the Storage operator.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="exportMetrics")
    def export_metrics(self) -> Optional[pulumi.Input[bool]]:
        """
        If this flag is enabled it will expose the storage cluster metrics to Prometheus.
        """
        return pulumi.get(self, "export_metrics")

    @export_metrics.setter
    def export_metrics(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "export_metrics", value)

    @property
    @pulumi.getter(name="remoteWriteEndpoint")
    def remote_write_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the remote write endpoint for Prometheus.
        """
        return pulumi.get(self, "remote_write_endpoint")

    @remote_write_endpoint.setter
    def remote_write_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "remote_write_endpoint", value)


@pulumi.input_type
class StorageClusterSpecNetworkArgs:
    def __init__(__self__, *,
                 data_interface: Optional[pulumi.Input[str]] = None,
                 mgmt_interface: Optional[pulumi.Input[str]] = None):
        """
        Contains network information that is needed by the storage driver.
        :param pulumi.Input[str] data_interface: Name of the network interface used by the storage driver for data traffic.
        :param pulumi.Input[str] mgmt_interface: Name of the network interface used by the storage driver for management traffic.
        """
        if data_interface is not None:
            pulumi.set(__self__, "data_interface", data_interface)
        if mgmt_interface is not None:
            pulumi.set(__self__, "mgmt_interface", mgmt_interface)

    @property
    @pulumi.getter(name="dataInterface")
    def data_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for data traffic.
        """
        return pulumi.get(self, "data_interface")

    @data_interface.setter
    def data_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_interface", value)

    @property
    @pulumi.getter(name="mgmtInterface")
    def mgmt_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for management traffic.
        """
        return pulumi.get(self, "mgmt_interface")

    @mgmt_interface.setter
    def mgmt_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mgmt_interface", value)


@pulumi.input_type
class StorageClusterSpecNodesArgs:
    def __init__(__self__, *,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]]] = None,
                 network: Optional[pulumi.Input['StorageClusterSpecNodesNetworkArgs']] = None,
                 runtime_options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 selector: Optional[pulumi.Input['StorageClusterSpecNodesSelectorArgs']] = None,
                 storage: Optional[pulumi.Input['StorageClusterSpecNodesStorageArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]] env: List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Environment variables specified here at the node level will be merged with the ones present in cluster configuration and sent to the nodes. If there is duplicate, the node level value will take precedence.
        :param pulumi.Input['StorageClusterSpecNodesNetworkArgs'] network: Contains network information that is needed by the storage driver.
        :param pulumi.Input[Mapping[str, Any]] runtime_options: This is map of any runtime options that need to be sent to the storage driver. The value is a string. If runtime options are present here at node level, they will override the ones from cluster configuration.
        :param pulumi.Input['StorageClusterSpecNodesSelectorArgs'] selector: Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.
        :param pulumi.Input['StorageClusterSpecNodesStorageArgs'] storage: Details of the storage used by the storage driver.
        """
        if env is not None:
            pulumi.set(__self__, "env", env)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if runtime_options is not None:
            pulumi.set(__self__, "runtime_options", runtime_options)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if storage is not None:
            pulumi.set(__self__, "storage", storage)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]]]:
        """
        List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Environment variables specified here at the node level will be merged with the ones present in cluster configuration and sent to the nodes. If there is duplicate, the node level value will take precedence.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['StorageClusterSpecNodesNetworkArgs']]:
        """
        Contains network information that is needed by the storage driver.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['StorageClusterSpecNodesNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="runtimeOptions")
    def runtime_options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        This is map of any runtime options that need to be sent to the storage driver. The value is a string. If runtime options are present here at node level, they will override the ones from cluster configuration.
        """
        return pulumi.get(self, "runtime_options")

    @runtime_options.setter
    def runtime_options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "runtime_options", value)

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input['StorageClusterSpecNodesSelectorArgs']]:
        """
        Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.
        """
        return pulumi.get(self, "selector")

    @selector.setter
    def selector(self, value: Optional[pulumi.Input['StorageClusterSpecNodesSelectorArgs']]):
        pulumi.set(self, "selector", value)

    @property
    @pulumi.getter
    def storage(self) -> Optional[pulumi.Input['StorageClusterSpecNodesStorageArgs']]:
        """
        Details of the storage used by the storage driver.
        """
        return pulumi.get(self, "storage")

    @storage.setter
    def storage(self, value: Optional[pulumi.Input['StorageClusterSpecNodesStorageArgs']]):
        pulumi.set(self, "storage", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecNodesEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecNodesNetworkArgs:
    def __init__(__self__, *,
                 data_interface: Optional[pulumi.Input[str]] = None,
                 mgmt_interface: Optional[pulumi.Input[str]] = None):
        """
        Contains network information that is needed by the storage driver.
        :param pulumi.Input[str] data_interface: Name of the network interface used by the storage driver for data traffic.
        :param pulumi.Input[str] mgmt_interface: Name of the network interface used by the storage driver for management traffic.
        """
        if data_interface is not None:
            pulumi.set(__self__, "data_interface", data_interface)
        if mgmt_interface is not None:
            pulumi.set(__self__, "mgmt_interface", mgmt_interface)

    @property
    @pulumi.getter(name="dataInterface")
    def data_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for data traffic.
        """
        return pulumi.get(self, "data_interface")

    @data_interface.setter
    def data_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_interface", value)

    @property
    @pulumi.getter(name="mgmtInterface")
    def mgmt_interface(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the network interface used by the storage driver for management traffic.
        """
        return pulumi.get(self, "mgmt_interface")

    @mgmt_interface.setter
    def mgmt_interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mgmt_interface", value)


@pulumi.input_type
class StorageClusterSpecNodesSelectorArgs:
    def __init__(__self__, *,
                 label_selector: Optional[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs']] = None,
                 node_name: Optional[pulumi.Input[str]] = None):
        """
        Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.
        :param pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs'] label_selector: It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.
        :param pulumi.Input[str] node_name: Name of the Kubernetes node that is to be selected. If present then the labelSelector is ignored even if the node with the given name is absent and the labelSelector matches another node.
        """
        if label_selector is not None:
            pulumi.set(__self__, "label_selector", label_selector)
        if node_name is not None:
            pulumi.set(__self__, "node_name", node_name)

    @property
    @pulumi.getter(name="labelSelector")
    def label_selector(self) -> Optional[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs']]:
        """
        It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.
        """
        return pulumi.get(self, "label_selector")

    @label_selector.setter
    def label_selector(self, value: Optional[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs']]):
        pulumi.set(self, "label_selector", value)

    @property
    @pulumi.getter(name="nodeName")
    def node_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the Kubernetes node that is to be selected. If present then the labelSelector is ignored even if the node with the given name is absent and the labelSelector matches another node.
        """
        return pulumi.get(self, "node_name")

    @node_name.setter
    def node_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_name", value)


@pulumi.input_type
class StorageClusterSpecNodesSelectorLabelSelectorArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]]] = None,
                 match_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]] match_expressions: It is a list of label selector requirements. The requirements are ANDed.
        :param pulumi.Input[Mapping[str, Any]] match_labels: It is a map of key-value pairs. A single key-value in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]]]:
        """
        It is a list of label selector requirements. The requirements are ANDed.
        """
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        It is a map of key-value pairs. A single key-value in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
        """
        return pulumi.get(self, "match_labels")

    @match_labels.setter
    def match_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "match_labels", value)


@pulumi.input_type
class StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] key: It is the label key that the selector applies to.
        :param pulumi.Input[str] operator: It represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: It is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        It is the label key that the selector applies to.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        It represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        It is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecNodesStorageArgs:
    def __init__(__self__, *,
                 devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 force_use_disks: Optional[pulumi.Input[bool]] = None,
                 journal_device: Optional[pulumi.Input[str]] = None,
                 kvdb_device: Optional[pulumi.Input[str]] = None,
                 system_metadata_device: Optional[pulumi.Input[str]] = None,
                 use_all: Optional[pulumi.Input[bool]] = None,
                 use_all_with_partitions: Optional[pulumi.Input[bool]] = None):
        """
        Details of the storage used by the storage driver.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: List of devices to be used by the storage driver.
        :param pulumi.Input[bool] force_use_disks: Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        :param pulumi.Input[str] journal_device: Device used for journaling.
        :param pulumi.Input[str] kvdb_device: Device used for internal KVDB.
        :param pulumi.Input[str] system_metadata_device: Device that will be used to store system metadata by the driver.
        :param pulumi.Input[bool] use_all: Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        :param pulumi.Input[bool] use_all_with_partitions: Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if force_use_disks is not None:
            pulumi.set(__self__, "force_use_disks", force_use_disks)
        if journal_device is not None:
            pulumi.set(__self__, "journal_device", journal_device)
        if kvdb_device is not None:
            pulumi.set(__self__, "kvdb_device", kvdb_device)
        if system_metadata_device is not None:
            pulumi.set(__self__, "system_metadata_device", system_metadata_device)
        if use_all is not None:
            pulumi.set(__self__, "use_all", use_all)
        if use_all_with_partitions is not None:
            pulumi.set(__self__, "use_all_with_partitions", use_all_with_partitions)

    @property
    @pulumi.getter
    def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of devices to be used by the storage driver.
        """
        return pulumi.get(self, "devices")

    @devices.setter
    def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "devices", value)

    @property
    @pulumi.getter(name="forceUseDisks")
    def force_use_disks(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        """
        return pulumi.get(self, "force_use_disks")

    @force_use_disks.setter
    def force_use_disks(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force_use_disks", value)

    @property
    @pulumi.getter(name="journalDevice")
    def journal_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for journaling.
        """
        return pulumi.get(self, "journal_device")

    @journal_device.setter
    def journal_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "journal_device", value)

    @property
    @pulumi.getter(name="kvdbDevice")
    def kvdb_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for internal KVDB.
        """
        return pulumi.get(self, "kvdb_device")

    @kvdb_device.setter
    def kvdb_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvdb_device", value)

    @property
    @pulumi.getter(name="systemMetadataDevice")
    def system_metadata_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device that will be used to store system metadata by the driver.
        """
        return pulumi.get(self, "system_metadata_device")

    @system_metadata_device.setter
    def system_metadata_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "system_metadata_device", value)

    @property
    @pulumi.getter(name="useAll")
    def use_all(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all")

    @use_all.setter
    def use_all(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all", value)

    @property
    @pulumi.getter(name="useAllWithPartitions")
    def use_all_with_partitions(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all_with_partitions")

    @use_all_with_partitions.setter
    def use_all_with_partitions(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all_with_partitions", value)


@pulumi.input_type
class StorageClusterSpecPlacementArgs:
    def __init__(__self__, *,
                 node_affinity: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs']] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]]] = None):
        """
        Describes placement configuration for the storage cluster pods.
        :param pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]] tolerations: Tolerations for all the pods deployed by the StorageCluster controller. The pod with this toleration attached will tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>.
        """
        if node_affinity is not None:
            pulumi.set(__self__, "node_affinity", node_affinity)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)

    @property
    @pulumi.getter(name="nodeAffinity")
    def node_affinity(self) -> Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs']]:
        """
        Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.
        """
        return pulumi.get(self, "node_affinity")

    @node_affinity.setter
    def node_affinity(self, value: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs']]):
        pulumi.set(self, "node_affinity", value)

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]]]:
        """
        Tolerations for all the pods deployed by the StorageCluster controller. The pod with this toleration attached will tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>.
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]]]):
        pulumi.set(self, "tolerations", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityArgs:
    def __init__(__self__, *,
                 preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]] = None,
                 required_during_scheduling_ignored_during_execution: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']] = None):
        """
        Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.
        """
        if preferred_during_scheduling_ignored_during_execution is not None:
            pulumi.set(__self__, "preferred_during_scheduling_ignored_during_execution", preferred_during_scheduling_ignored_during_execution)
        if required_during_scheduling_ignored_during_execution is not None:
            pulumi.set(__self__, "required_during_scheduling_ignored_during_execution", required_during_scheduling_ignored_during_execution)

    @property
    @pulumi.getter(name="preferredDuringSchedulingIgnoredDuringExecution")
    def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
        return pulumi.get(self, "preferred_during_scheduling_ignored_during_execution")

    @preferred_during_scheduling_ignored_during_execution.setter
    def preferred_during_scheduling_ignored_during_execution(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]):
        pulumi.set(self, "preferred_during_scheduling_ignored_during_execution", value)

    @property
    @pulumi.getter(name="requiredDuringSchedulingIgnoredDuringExecution")
    def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]:
        return pulumi.get(self, "required_during_scheduling_ignored_during_execution")

    @required_during_scheduling_ignored_during_execution.setter
    def required_during_scheduling_ignored_during_execution(self, value: Optional[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]):
        pulumi.set(self, "required_during_scheduling_ignored_during_execution", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs:
    def __init__(__self__, *,
                 preference: pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'],
                 weight: pulumi.Input[int]):
        pulumi.set(__self__, "preference", preference)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def preference(self) -> pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']:
        return pulumi.get(self, "preference")

    @preference.setter
    def preference(self, value: pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']):
        pulumi.set(self, "preference", value)

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[int]:
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[int]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]] = None,
                 match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]] = None):
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_fields is not None:
            pulumi.set(__self__, "match_fields", match_fields)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]:
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchFields")
    def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]:
        return pulumi.get(self, "match_fields")

    @match_fields.setter
    def match_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]):
        pulumi.set(self, "match_fields", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs:
    def __init__(__self__, *,
                 node_selector_terms: pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
        pulumi.set(__self__, "node_selector_terms", node_selector_terms)

    @property
    @pulumi.getter(name="nodeSelectorTerms")
    def node_selector_terms(self) -> pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]:
        return pulumi.get(self, "node_selector_terms")

    @node_selector_terms.setter
    def node_selector_terms(self, value: pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
        pulumi.set(self, "node_selector_terms", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]] = None,
                 match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]] = None):
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_fields is not None:
            pulumi.set(__self__, "match_fields", match_fields)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]:
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchFields")
    def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]:
        return pulumi.get(self, "match_fields")

    @match_fields.setter
    def match_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]):
        pulumi.set(self, "match_fields", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class StorageClusterSpecPlacementTolerationsArgs:
    def __init__(__self__, *,
                 effect: Optional[pulumi.Input[str]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 toleration_seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
        :param pulumi.Input[str] key: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
        :param pulumi.Input[str] operator: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
        :param pulumi.Input[int] toleration_seconds: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
        :param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
        """
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if toleration_seconds is not None:
            pulumi.set(__self__, "toleration_seconds", toleration_seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input[str]]:
        """
        Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
        """
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter(name="tolerationSeconds")
    def toleration_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
        """
        return pulumi.get(self, "toleration_seconds")

    @toleration_seconds.setter
    def toleration_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "toleration_seconds", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class StorageClusterSpecStorageArgs:
    def __init__(__self__, *,
                 devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 force_use_disks: Optional[pulumi.Input[bool]] = None,
                 journal_device: Optional[pulumi.Input[str]] = None,
                 kvdb_device: Optional[pulumi.Input[str]] = None,
                 system_metadata_device: Optional[pulumi.Input[str]] = None,
                 use_all: Optional[pulumi.Input[bool]] = None,
                 use_all_with_partitions: Optional[pulumi.Input[bool]] = None):
        """
        Details of the storage used by the storage driver.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: List of devices to be used by the storage driver.
        :param pulumi.Input[bool] force_use_disks: Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        :param pulumi.Input[str] journal_device: Device used for journaling.
        :param pulumi.Input[str] kvdb_device: Device used for internal KVDB.
        :param pulumi.Input[str] system_metadata_device: Device that will be used to store system metadata by the driver.
        :param pulumi.Input[bool] use_all: Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        :param pulumi.Input[bool] use_all_with_partitions: Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if force_use_disks is not None:
            pulumi.set(__self__, "force_use_disks", force_use_disks)
        if journal_device is not None:
            pulumi.set(__self__, "journal_device", journal_device)
        if kvdb_device is not None:
            pulumi.set(__self__, "kvdb_device", kvdb_device)
        if system_metadata_device is not None:
            pulumi.set(__self__, "system_metadata_device", system_metadata_device)
        if use_all is not None:
            pulumi.set(__self__, "use_all", use_all)
        if use_all_with_partitions is not None:
            pulumi.set(__self__, "use_all_with_partitions", use_all_with_partitions)

    @property
    @pulumi.getter
    def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of devices to be used by the storage driver.
        """
        return pulumi.get(self, "devices")

    @devices.setter
    def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "devices", value)

    @property
    @pulumi.getter(name="forceUseDisks")
    def force_use_disks(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.
        """
        return pulumi.get(self, "force_use_disks")

    @force_use_disks.setter
    def force_use_disks(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force_use_disks", value)

    @property
    @pulumi.getter(name="journalDevice")
    def journal_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for journaling.
        """
        return pulumi.get(self, "journal_device")

    @journal_device.setter
    def journal_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "journal_device", value)

    @property
    @pulumi.getter(name="kvdbDevice")
    def kvdb_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device used for internal KVDB.
        """
        return pulumi.get(self, "kvdb_device")

    @kvdb_device.setter
    def kvdb_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvdb_device", value)

    @property
    @pulumi.getter(name="systemMetadataDevice")
    def system_metadata_device(self) -> Optional[pulumi.Input[str]]:
        """
        Device that will be used to store system metadata by the driver.
        """
        return pulumi.get(self, "system_metadata_device")

    @system_metadata_device.setter
    def system_metadata_device(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "system_metadata_device", value)

    @property
    @pulumi.getter(name="useAll")
    def use_all(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all")

    @use_all.setter
    def use_all(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all", value)

    @property
    @pulumi.getter(name="useAllWithPartitions")
    def use_all_with_partitions(self) -> Optional[pulumi.Input[bool]]:
        """
        Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty.
        """
        return pulumi.get(self, "use_all_with_partitions")

    @use_all_with_partitions.setter
    def use_all_with_partitions(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_all_with_partitions", value)


@pulumi.input_type
class StorageClusterSpecStorkArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 lock_image: Optional[pulumi.Input[bool]] = None):
        """
        Contains STORK related spec.
        :param pulumi.Input[Mapping[str, Any]] args: It is map of arguments given to STORK. Example: driver: pxd
        :param pulumi.Input[bool] enabled: Flag indicating whether STORK needs to be enabled.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]] env: List of environment variables used by STORK. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[str] image: Docker image of the STORK container.
        :param pulumi.Input[bool] lock_image: Flag indicating if the STORK image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if lock_image is not None:
            pulumi.set(__self__, "lock_image", lock_image)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        It is map of arguments given to STORK. Example: driver: pxd
        """
        return pulumi.get(self, "args")

    @args.setter
    def args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "args", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether STORK needs to be enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]]]:
        """
        List of environment variables used by STORK. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the STORK container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="lockImage")
    def lock_image(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating if the STORK image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        return pulumi.get(self, "lock_image")

    @lock_image.setter
    def lock_image(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lock_image", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecStorkEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs']] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        An update strategy to replace existing StorageCluster pods with new pods.
        :param pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs'] rolling_update: Spec to control the desired behavior of storage cluster rolling update.
        :param pulumi.Input[str] type: Type of storage cluster update. Can be RollingUpdate or OnDelete. Default is RollingUpdate.
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional[pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs']]:
        """
        Spec to control the desired behavior of storage cluster rolling update.
        """
        return pulumi.get(self, "rolling_update")

    @rolling_update.setter
    def rolling_update(self, value: Optional[pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs']]):
        pulumi.set(self, "rolling_update", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of storage cluster update. Can be RollingUpdate or OnDelete. Default is RollingUpdate.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterSpecUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_unavailable: Optional[pulumi.Input[Union[int, str]]] = None):
        """
        Spec to control the desired behavior of storage cluster rolling update.
        :param pulumi.Input[Union[int, str]] max_unavailable: The maximum number of StorageCluster pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of StorageCluster pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the storage pod can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those StorageCluster pods and then brings up new StorageCluster pods in their place. Once the new pods are available, it then proceeds onto other StorageCluster pods, thus ensuring that at least 70% of original number of StorageCluster pods are available at all times during the update.
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[Union[int, str]]]:
        """
        The maximum number of StorageCluster pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of StorageCluster pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the storage pod can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those StorageCluster pods and then brings up new StorageCluster pods in their place. Once the new pods are available, it then proceeds onto other StorageCluster pods, thus ensuring that at least 70% of original number of StorageCluster pods are available at all times during the update.
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[Union[int, str]]]):
        pulumi.set(self, "max_unavailable", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 lock_image: Optional[pulumi.Input[bool]] = None):
        """
        Contains spec of a user interface for the storage driver.
        :param pulumi.Input[bool] enabled: Flag indicating whether the user interface needs to be enabled.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]] env: List of environment variables used by the UI components. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        :param pulumi.Input[str] image: Docker image of the user interface container.
        :param pulumi.Input[bool] lock_image: Flag indicating if the user interface image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if lock_image is not None:
            pulumi.set(__self__, "lock_image", lock_image)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether the user interface needs to be enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]]]:
        """
        List of environment variables used by the UI components. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image of the user interface container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="lockImage")
    def lock_image(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating if the user interface image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.
        """
        return pulumi.get(self, "lock_image")

    @lock_image.setter
    def lock_image(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lock_image", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromArgs']]:
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromArgs']]):
        pulumi.set(self, "value_from", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromArgs:
    def __init__(__self__, *,
                 config_map_key_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs']] = None,
                 field_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs']] = None,
                 resource_field_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs']] = None,
                 secret_key_ref: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs']] = None):
        if config_map_key_ref is not None:
            pulumi.set(__self__, "config_map_key_ref", config_map_key_ref)
        if field_ref is not None:
            pulumi.set(__self__, "field_ref", field_ref)
        if resource_field_ref is not None:
            pulumi.set(__self__, "resource_field_ref", resource_field_ref)
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="configMapKeyRef")
    def config_map_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs']]:
        return pulumi.get(self, "config_map_key_ref")

    @config_map_key_ref.setter
    def config_map_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs']]):
        pulumi.set(self, "config_map_key_ref", value)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs']]:
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs']]):
        pulumi.set(self, "field_ref", value)

    @property
    @pulumi.getter(name="resourceFieldRef")
    def resource_field_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs']]:
        return pulumi.get(self, "resource_field_ref")

    @resource_field_ref.setter
    def resource_field_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs']]):
        pulumi.set(self, "resource_field_ref", value)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs']]:
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromConfigMapKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromFieldRefArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 field_path: Optional[pulumi.Input[str]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)

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

    @field_path.setter
    def field_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "field_path", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromResourceFieldRefArgs:
    def __init__(__self__, *,
                 container_name: Optional[pulumi.Input[str]] = None,
                 divisor: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None):
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if divisor is not None:
            pulumi.set(__self__, "divisor", divisor)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

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

    @container_name.setter
    def container_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def divisor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "divisor")

    @divisor.setter
    def divisor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "divisor", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)


@pulumi.input_type
class StorageClusterSpecUserInterfaceEnvValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 optional: Optional[pulumi.Input[bool]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if optional is not None:
            pulumi.set(__self__, "optional", optional)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def optional(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "optional")

    @optional.setter
    def optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "optional", value)


@pulumi.input_type
class StorageClusterStatusArgs:
    def __init__(__self__, *,
                 cluster_name: Optional[pulumi.Input[str]] = None,
                 cluster_uid: Optional[pulumi.Input[str]] = None,
                 collision_count: Optional[pulumi.Input[int]] = None,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]]] = None,
                 phase: Optional[pulumi.Input[str]] = None,
                 storage: Optional[pulumi.Input['StorageClusterStatusStorageArgs']] = None):
        """
        Most recently observed status of the storage cluster. This data may not be up to date.
        :param pulumi.Input[str] cluster_name: Name of the storage cluster.
        :param pulumi.Input[str] cluster_uid: Unique ID of the storage cluster.
        :param pulumi.Input[int] collision_count: Count of hash collisions for the StorageCluster. The StorageCluster controller uses this field as a collision avoidance mechanism when it needs to create the name of the newest ControllerRevision.
        :param pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]] conditions: Contains details for the current condition of this cluster.
        :param pulumi.Input[str] phase: Phase of the StorageCluster is a simple, high-level summary of where the StorageCluster is in its lifecycle. The condition array contains more detailed information about the state of the cluster.
        :param pulumi.Input['StorageClusterStatusStorageArgs'] storage: Contains details of storage in the cluster.
        """
        if cluster_name is not None:
            pulumi.set(__self__, "cluster_name", cluster_name)
        if cluster_uid is not None:
            pulumi.set(__self__, "cluster_uid", cluster_uid)
        if collision_count is not None:
            pulumi.set(__self__, "collision_count", collision_count)
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)
        if storage is not None:
            pulumi.set(__self__, "storage", storage)

    @property
    @pulumi.getter(name="clusterName")
    def cluster_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the storage cluster.
        """
        return pulumi.get(self, "cluster_name")

    @cluster_name.setter
    def cluster_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_name", value)

    @property
    @pulumi.getter(name="clusterUid")
    def cluster_uid(self) -> Optional[pulumi.Input[str]]:
        """
        Unique ID of the storage cluster.
        """
        return pulumi.get(self, "cluster_uid")

    @cluster_uid.setter
    def cluster_uid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_uid", value)

    @property
    @pulumi.getter(name="collisionCount")
    def collision_count(self) -> Optional[pulumi.Input[int]]:
        """
        Count of hash collisions for the StorageCluster. The StorageCluster controller uses this field as a collision avoidance mechanism when it needs to create the name of the newest ControllerRevision.
        """
        return pulumi.get(self, "collision_count")

    @collision_count.setter
    def collision_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "collision_count", value)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]]]:
        """
        Contains details for the current condition of this cluster.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[str]]:
        """
        Phase of the StorageCluster is a simple, high-level summary of where the StorageCluster is in its lifecycle. The condition array contains more detailed information about the state of the cluster.
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "phase", value)

    @property
    @pulumi.getter
    def storage(self) -> Optional[pulumi.Input['StorageClusterStatusStorageArgs']]:
        """
        Contains details of storage in the cluster.
        """
        return pulumi.get(self, "storage")

    @storage.setter
    def storage(self, value: Optional[pulumi.Input['StorageClusterStatusStorageArgs']]):
        pulumi.set(self, "storage", value)


@pulumi.input_type
class StorageClusterStatusConditionsArgs:
    def __init__(__self__, *,
                 reason: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] reason: Reason is human readable message indicating details about the current state of the cluster.
        :param pulumi.Input[str] status: Status of the condition.
        :param pulumi.Input[str] type: Type of the condition.
        """
        if reason is not None:
            pulumi.set(__self__, "reason", reason)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def reason(self) -> Optional[pulumi.Input[str]]:
        """
        Reason is human readable message indicating details about the current state of the cluster.
        """
        return pulumi.get(self, "reason")

    @reason.setter
    def reason(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "reason", value)

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        Status of the condition.
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "status", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the condition.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageClusterStatusStorageArgs:
    def __init__(__self__, *,
                 storage_nodes_per_zone: Optional[pulumi.Input[int]] = None):
        """
        Contains details of storage in the cluster.
        :param pulumi.Input[int] storage_nodes_per_zone: The number of storage nodes per zone in the cluster.
        """
        if storage_nodes_per_zone is not None:
            pulumi.set(__self__, "storage_nodes_per_zone", storage_nodes_per_zone)

    @property
    @pulumi.getter(name="storageNodesPerZone")
    def storage_nodes_per_zone(self) -> Optional[pulumi.Input[int]]:
        """
        The number of storage nodes per zone in the cluster.
        """
        return pulumi.get(self, "storage_nodes_per_zone")

    @storage_nodes_per_zone.setter
    def storage_nodes_per_zone(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "storage_nodes_per_zone", value)


@pulumi.input_type
class StorageNodeSpecArgs:
    def __init__(__self__, *,
                 cloud_storage: Optional[pulumi.Input['StorageNodeSpecCloudStorageArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        The desired behavior of the storage node. Currently changing the spec does not affect the actual storage node in the cluster. Eventually spec in StorageNode will override the spec from StorageCluster so that configuration can be overridden at node level.
        :param pulumi.Input['StorageNodeSpecCloudStorageArgs'] cloud_storage: Details of storage on the node for cloud environments.
        :param pulumi.Input[str] version: Version of the storage driver on the node.
        """
        if cloud_storage is not None:
            pulumi.set(__self__, "cloud_storage", cloud_storage)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="cloudStorage")
    def cloud_storage(self) -> Optional[pulumi.Input['StorageNodeSpecCloudStorageArgs']]:
        """
        Details of storage on the node for cloud environments.
        """
        return pulumi.get(self, "cloud_storage")

    @cloud_storage.setter
    def cloud_storage(self, value: Optional[pulumi.Input['StorageNodeSpecCloudStorageArgs']]):
        pulumi.set(self, "cloud_storage", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        Version of the storage driver on the node.
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class StorageNodeSpecCloudStorageArgs:
    def __init__(__self__, *,
                 drive_configs: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]]] = None):
        """
        Details of storage on the node for cloud environments.
        :param pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]] drive_configs: List of cloud drive configs for the storage node.
        """
        if drive_configs is not None:
            pulumi.set(__self__, "drive_configs", drive_configs)

    @property
    @pulumi.getter(name="driveConfigs")
    def drive_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]]]:
        """
        List of cloud drive configs for the storage node.
        """
        return pulumi.get(self, "drive_configs")

    @drive_configs.setter
    def drive_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]]]):
        pulumi.set(self, "drive_configs", value)


@pulumi.input_type
class StorageNodeSpecCloudStorageDriveConfigsArgs:
    def __init__(__self__, *,
                 iops: Optional[pulumi.Input[int]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 size_in_gi_b: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] iops: IOPS required from the cloud drive.
        :param pulumi.Input[Mapping[str, Any]] options: Additional options for the cloud drive.
        :param pulumi.Input[int] size_in_gi_b: Size of cloud drive in GiB.
        :param pulumi.Input[str] type: Type of cloud drive.
        """
        if iops is not None:
            pulumi.set(__self__, "iops", iops)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if size_in_gi_b is not None:
            pulumi.set(__self__, "size_in_gi_b", size_in_gi_b)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def iops(self) -> Optional[pulumi.Input[int]]:
        """
        IOPS required from the cloud drive.
        """
        return pulumi.get(self, "iops")

    @iops.setter
    def iops(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "iops", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Additional options for the cloud drive.
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter(name="sizeInGiB")
    def size_in_gi_b(self) -> Optional[pulumi.Input[int]]:
        """
        Size of cloud drive in GiB.
        """
        return pulumi.get(self, "size_in_gi_b")

    @size_in_gi_b.setter
    def size_in_gi_b(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size_in_gi_b", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of cloud drive.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageNodeStatusArgs:
    def __init__(__self__, *,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]]] = None,
                 geography: Optional[pulumi.Input['StorageNodeStatusGeographyArgs']] = None,
                 network: Optional[pulumi.Input['StorageNodeStatusNetworkArgs']] = None,
                 node_uid: Optional[pulumi.Input[str]] = None,
                 phase: Optional[pulumi.Input[str]] = None):
        """
        Most recently observed status of the storage node. The data may not be up to date.
        :param pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]] conditions: Contains details for the current condition of this storage node.
        :param pulumi.Input['StorageNodeStatusGeographyArgs'] geography: Contains topology information for the storage node.
        :param pulumi.Input[str] node_uid: Unique ID of the storage node.
        :param pulumi.Input[str] phase: Phase of the StorageNode is a simple, high-level summary of where the StorageNode is in its lifecycle. The condition array contains more detailed information about the state of the node.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if geography is not None:
            pulumi.set(__self__, "geography", geography)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if node_uid is not None:
            pulumi.set(__self__, "node_uid", node_uid)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]]]:
        """
        Contains details for the current condition of this storage node.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def geography(self) -> Optional[pulumi.Input['StorageNodeStatusGeographyArgs']]:
        """
        Contains topology information for the storage node.
        """
        return pulumi.get(self, "geography")

    @geography.setter
    def geography(self, value: Optional[pulumi.Input['StorageNodeStatusGeographyArgs']]):
        pulumi.set(self, "geography", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['StorageNodeStatusNetworkArgs']]:
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['StorageNodeStatusNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="nodeUid")
    def node_uid(self) -> Optional[pulumi.Input[str]]:
        """
        Unique ID of the storage node.
        """
        return pulumi.get(self, "node_uid")

    @node_uid.setter
    def node_uid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_uid", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[str]]:
        """
        Phase of the StorageNode is a simple, high-level summary of where the StorageNode is in its lifecycle. The condition array contains more detailed information about the state of the node.
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "phase", value)


@pulumi.input_type
class StorageNodeStatusConditionsArgs:
    def __init__(__self__, *,
                 reason: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] reason: Reason is the human readable message indicating details about the current state of the cluster.
        :param pulumi.Input[str] status: Status of the condition.
        :param pulumi.Input[str] type: Type of the condition.
        """
        if reason is not None:
            pulumi.set(__self__, "reason", reason)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def reason(self) -> Optional[pulumi.Input[str]]:
        """
        Reason is the human readable message indicating details about the current state of the cluster.
        """
        return pulumi.get(self, "reason")

    @reason.setter
    def reason(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "reason", value)

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        Status of the condition.
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "status", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the condition.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class StorageNodeStatusGeographyArgs:
    def __init__(__self__, *,
                 rack: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        """
        Contains topology information for the storage node.
        :param pulumi.Input[str] rack: Rack on which the storage node is placed.
        :param pulumi.Input[str] region: Region in which the storage node is placed.
        :param pulumi.Input[str] zone: Zone in which the storage node is placed.
        """
        if rack is not None:
            pulumi.set(__self__, "rack", rack)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter
    def rack(self) -> Optional[pulumi.Input[str]]:
        """
        Rack on which the storage node is placed.
        """
        return pulumi.get(self, "rack")

    @rack.setter
    def rack(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rack", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        Region in which the storage node is placed.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter
    def zone(self) -> Optional[pulumi.Input[str]]:
        """
        Zone in which the storage node is placed.
        """
        return pulumi.get(self, "zone")

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


@pulumi.input_type
class StorageNodeStatusNetworkArgs:
    def __init__(__self__, *,
                 data_ip: Optional[pulumi.Input[str]] = None,
                 mgmt_ip: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] data_ip: IP address used by the storage driver for data traffic.
        :param pulumi.Input[str] mgmt_ip: IP address used by the storage driver for management traffic.
        """
        if data_ip is not None:
            pulumi.set(__self__, "data_ip", data_ip)
        if mgmt_ip is not None:
            pulumi.set(__self__, "mgmt_ip", mgmt_ip)

    @property
    @pulumi.getter(name="dataIP")
    def data_ip(self) -> Optional[pulumi.Input[str]]:
        """
        IP address used by the storage driver for data traffic.
        """
        return pulumi.get(self, "data_ip")

    @data_ip.setter
    def data_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_ip", value)

    @property
    @pulumi.getter(name="mgmtIP")
    def mgmt_ip(self) -> Optional[pulumi.Input[str]]:
        """
        IP address used by the storage driver for management traffic.
        """
        return pulumi.get(self, "mgmt_ip")

    @mgmt_ip.setter
    def mgmt_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mgmt_ip", value)



# coding=utf-8 # *** WARNING: this file was generated by crd2pulumi. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** The desired behavior of the storage cluster.         :param pulumi.Input['StorageClusterSpecAutopilotArgs'] autopilot: Contains spec of autopilot component for storage driver.         :param pulumi.Input['StorageClusterSpecCloudStorageArgs'] cloud_storage: Details of storage used in cloud environment.         :param pulumi.Input[str] custom_image_registry: Custom container image registry server that will be used instead of index.docker.io to download Docker images. This may include the repository as well. (Example: myregistry.net:5443 or myregistry.com/myrepository)         :param pulumi.Input['StorageClusterSpecDeleteStrategyArgs'] delete_strategy: Delete strategy to uninstall and wipe the storage cluster.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecEnvArgs']]] env: List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.         :param pulumi.Input[Mapping[str, Any]] feature_gates: This is a map of feature names to string values.         :param pulumi.Input[str] image: Docker image of the storage driver.         :param pulumi.Input[str] image_pull_policy: Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always.         :param pulumi.Input[str] image_pull_secret: Image pull secret is a reference to secret in the same namespace as the StorageCluster. It is used for pulling all images used by the StorageCluster.         :param pulumi.Input['StorageClusterSpecKvdbArgs'] kvdb: Details of KVDB that the storage driver will use.         :param pulumi.Input['StorageClusterSpecMonitoringArgs'] monitoring: Contains monitoring configuration for the storage cluster.         :param pulumi.Input['StorageClusterSpecNetworkArgs'] network: Contains network information that is needed by the storage driver.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesArgs']]] nodes: Node level configurations that will override the configuration at cluster level. These configurations can be for individual nodes or can be grouped to override configuration of multiple nodes based on label selectors.         :param pulumi.Input['StorageClusterSpecPlacementArgs'] placement: Describes placement configuration for the storage cluster pods.         :param pulumi.Input[int] revision_history_limit: The number of old history to retain to allow rollback. This is a pointer to distinguish between an explicit zero and not specified. Defaults to 10.         :param pulumi.Input[Mapping[str, Any]] runtime_options: This is map of any runtime options that need to be sent to the storage driver. The value is a string.         :param pulumi.Input[str] secrets_provider: Secrets provider is the name of secret provider that driver will connect to.         :param pulumi.Input[int] start_port: Start port is the starting port in the range of ports used by the cluster.         :param pulumi.Input['StorageClusterSpecStorageArgs'] storage: Details of the storage used by the storage driver.         :param pulumi.Input['StorageClusterSpecStorkArgs'] stork: Contains STORK related spec.         :param pulumi.Input['StorageClusterSpecUpdateStrategyArgs'] update_strategy: An update strategy to replace existing StorageCluster pods with new pods.         :param pulumi.Input['StorageClusterSpecUserInterfaceArgs'] user_interface: Contains spec of a user interface for the storage driver.         :param pulumi.Input[str] version: Version of the storage driver. This field is read-only. Contains spec of autopilot component for storage driver. Details of storage used in cloud environment. Custom container image registry server that will be used instead of index.docker.io to download Docker images. This may include the repository as well. (Example: myregistry.net:5443 or myregistry.com/myrepository) Delete strategy to uninstall and wipe the storage cluster. List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. This is a map of feature names to string values. Docker image of the storage driver. Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always. Image pull secret is a reference to secret in the same namespace as the StorageCluster. It is used for pulling all images used by the StorageCluster. Details of KVDB that the storage driver will use. Contains monitoring configuration for the storage cluster. Contains network information that is needed by the storage driver. Node level configurations that will override the configuration at cluster level. These configurations can be for individual nodes or can be grouped to override configuration of multiple nodes based on label selectors. Describes placement configuration for the storage cluster pods. The number of old history to retain to allow rollback. This is a pointer to distinguish between an explicit zero and not specified. Defaults to 10. This is map of any runtime options that need to be sent to the storage driver. The value is a string. Secrets provider is the name of secret provider that driver will connect to. Start port is the starting port in the range of ports used by the cluster. Details of the storage used by the storage driver. Contains STORK related spec. An update strategy to replace existing StorageCluster pods with new pods. Contains spec of a user interface for the storage driver. Version of the storage driver. This field is read-only. Contains spec of autopilot component for storage driver.         :param pulumi.Input[Mapping[str, Any]] args: It is a map of arguments provided to autopilot. Example: log-level: debug         :param pulumi.Input[bool] enabled: Flag indicating whether autopilot needs to be enabled.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotEnvArgs']]] env: List of environment variables used by autopilot. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.         :param pulumi.Input[str] image: Docker image of the autopilot container.         :param pulumi.Input[bool] lock_image: Flag indicating if the autopilot image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecAutopilotProvidersArgs']]] providers: List of input data providers to autopilot. It is a map of arguments provided to autopilot. Example: log-level: debug Flag indicating whether autopilot needs to be enabled. List of environment variables used by autopilot. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Docker image of the autopilot container. Flag indicating if the autopilot image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades. List of input data providers to autopilot. :param pulumi.Input[str] name: Unique name of the data provider.         :param pulumi.Input[Mapping[str, Any]] params: Map of key-value params for the provider.         :param pulumi.Input[str] type: Type of the data provider. For instance - prometheus Unique name of the data provider. Map of key-value params for the provider. Type of the data provider. For instance - prometheus Details of storage used in cloud environment.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecCloudStorageCapacitySpecsArgs']]] capacity_specs: List of cluster wide storage types and their capacities. A single capacity spec identifies a storage pool with a set of minimum requested IOPS and size. Based on the cloud provider, the total storage capacity will get divided amongst the nodes. The nodes bearing storage themselves will get uniformly distributed across all the zones.         :param pulumi.Input[Sequence[pulumi.Input[str]]] device_specs: List of storage device specs. A cloud storage device will be created for every spec in the list. The specs will be applied to all nodes in the cluster up to spec.cloudStorage.maxStorageNodes or spec.cloudStorage.maxStorageNodesPerZone. This will be ignored if spec.cloudStorage.capacitySpecs is present.         :param pulumi.Input[str] journal_device_spec: Device spec for the journal device.         :param pulumi.Input[str] kvdb_device_spec: Device spec for internal KVDB device.         :param pulumi.Input[int] max_storage_nodes: Maximum nodes that will have storage in the cluster.         :param pulumi.Input[int] max_storage_nodes_per_zone: Maximum nodes in every zone that will have storage in the cluster.         :param pulumi.Input[str] system_metadata_device_spec: Device spec for the metadata device. This device will be used to store system metadata by the driver. List of cluster wide storage types and their capacities. A single capacity spec identifies a storage pool with a set of minimum requested IOPS and size. Based on the cloud provider, the total storage capacity will get divided amongst the nodes. The nodes bearing storage themselves will get uniformly distributed across all the zones. List of storage device specs. A cloud storage device will be created for every spec in the list. The specs will be applied to all nodes in the cluster up to spec.cloudStorage.maxStorageNodes or spec.cloudStorage.maxStorageNodesPerZone. This will be ignored if spec.cloudStorage.capacitySpecs is present. Device spec for the journal device. Device spec for internal KVDB device. Maximum nodes that will have storage in the cluster. Maximum nodes in every zone that will have storage in the cluster. Device spec for the metadata device. This device will be used to store system metadata by the driver. :param pulumi.Input[int] max_capacity_in_gi_b: Maximum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be greater than this number for the entire cluster.         :param pulumi.Input[int] min_capacity_in_gi_b: Minimum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be less than this number for the entire cluster.         :param pulumi.Input[int] min_iops: Minimum IOPS expected from the cloud drive.         :param pulumi.Input[Mapping[str, Any]] options: Additional options required to provision the drive in cloud. Maximum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be greater than this number for the entire cluster. Minimum capacity for this storage cluster. The total capacity of devices created by this capacity spec should not be less than this number for the entire cluster. Minimum IOPS expected from the cloud drive. Additional options required to provision the drive in cloud. Delete strategy to uninstall and wipe the storage cluster.         :param pulumi.Input[str] type: Type of storage cluster delete. Can be Uninstall or UninstallAndWipe. There is no default delete strategy. When no delete strategy only objects managed by the StorageCluster controller and owned by the StorageCluster object are deleted. The storage driver will be left in a state where it will not be managed by any object. Uninstall strategy ensures that the cluster is completely uninstalled even from the storage driver perspective. UninstallAndWipe strategy ensures that the cluster is completely uninstalled as well as the storage devices and metadata are wiped for reuse. This may result in data loss. Type of storage cluster delete. Can be Uninstall or UninstallAndWipe. There is no default delete strategy. When no delete strategy only objects managed by the StorageCluster controller and owned by the StorageCluster object are deleted. The storage driver will be left in a state where it will not be managed by any object. Uninstall strategy ensures that the cluster is completely uninstalled even from the storage driver perspective. UninstallAndWipe strategy ensures that the cluster is completely uninstalled as well as the storage devices and metadata are wiped for reuse. This may result in data loss. Details of KVDB that the storage driver will use.         :param pulumi.Input[str] auth_secret: Authentication secret is the name of Kubernetes secret containing information to authenticate with the external KVDB. It could have the username/password for basic auth, certificate information or an ACL token.         :param pulumi.Input[Sequence[pulumi.Input[str]]] endpoints: If using external KVDB, this is the list of KVDB endpoints.         :param pulumi.Input[bool] internal: Flag indicating whether to use internal KVDB or an external KVDB. Authentication secret is the name of Kubernetes secret containing information to authenticate with the external KVDB. It could have the username/password for basic auth, certificate information or an ACL token. If using external KVDB, this is the list of KVDB endpoints. Flag indicating whether to use internal KVDB or an external KVDB. Contains monitoring configuration for the storage cluster.         :param pulumi.Input[bool] enable_metrics: If this flag is enabled it will expose the storage cluster metrics to external monitoring solutions like Prometheus. DEPRECATED - use prometheus.exportMetrics instead         :param pulumi.Input['StorageClusterSpecMonitoringPrometheusArgs'] prometheus: Contains configuration of Prometheus to monitor the storage cluster. If this flag is enabled it will expose the storage cluster metrics to external monitoring solutions like Prometheus. DEPRECATED - use prometheus.exportMetrics instead Contains configuration of Prometheus to monitor the storage cluster. Contains configuration of Prometheus to monitor the storage cluster.         :param pulumi.Input[bool] enabled: Flag indicating whether Prometheus stack needs to be enabled and deployed by the Storage operator.         :param pulumi.Input[bool] export_metrics: If this flag is enabled it will expose the storage cluster metrics to Prometheus.         :param pulumi.Input[str] remote_write_endpoint: Specifies the remote write endpoint for Prometheus. Flag indicating whether Prometheus stack needs to be enabled and deployed by the Storage operator. If this flag is enabled it will expose the storage cluster metrics to Prometheus. Specifies the remote write endpoint for Prometheus. Contains network information that is needed by the storage driver.         :param pulumi.Input[str] data_interface: Name of the network interface used by the storage driver for data traffic.         :param pulumi.Input[str] mgmt_interface: Name of the network interface used by the storage driver for management traffic. Name of the network interface used by the storage driver for data traffic. Name of the network interface used by the storage driver for management traffic. :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesEnvArgs']]] env: List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Environment variables specified here at the node level will be merged with the ones present in cluster configuration and sent to the nodes. If there is duplicate, the node level value will take precedence.         :param pulumi.Input['StorageClusterSpecNodesNetworkArgs'] network: Contains network information that is needed by the storage driver.         :param pulumi.Input[Mapping[str, Any]] runtime_options: This is map of any runtime options that need to be sent to the storage driver. The value is a string. If runtime options are present here at node level, they will override the ones from cluster configuration.         :param pulumi.Input['StorageClusterSpecNodesSelectorArgs'] selector: Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.         :param pulumi.Input['StorageClusterSpecNodesStorageArgs'] storage: Details of the storage used by the storage driver. List of environment variables used by the driver. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Environment variables specified here at the node level will be merged with the ones present in cluster configuration and sent to the nodes. If there is duplicate, the node level value will take precedence. Contains network information that is needed by the storage driver. This is map of any runtime options that need to be sent to the storage driver. The value is a string. If runtime options are present here at node level, they will override the ones from cluster configuration. Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored. Details of the storage used by the storage driver. Contains network information that is needed by the storage driver.         :param pulumi.Input[str] data_interface: Name of the network interface used by the storage driver for data traffic.         :param pulumi.Input[str] mgmt_interface: Name of the network interface used by the storage driver for management traffic. Name of the network interface used by the storage driver for data traffic. Name of the network interface used by the storage driver for management traffic. Configuration in this node block is applied to nodes based on this selector. Use either nodeName of labelSelector, not both. If nodeName is used, labelSelector will be ignored.         :param pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorArgs'] label_selector: It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.         :param pulumi.Input[str] node_name: Name of the Kubernetes node that is to be selected. If present then the labelSelector is ignored even if the node with the given name is absent and the labelSelector matches another node. It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects. Name of the Kubernetes node that is to be selected. If present then the labelSelector is ignored even if the node with the given name is absent and the labelSelector matches another node. It is a label query over all the nodes. The result of matchLabels and matchExpressions is ANDed. An empty label selector matches all nodes. A null label selector matches no objects.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecNodesSelectorLabelSelectorMatchExpressionsArgs']]] match_expressions: It is a list of label selector requirements. The requirements are ANDed.         :param pulumi.Input[Mapping[str, Any]] match_labels: It is a map of key-value pairs. A single key-value in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. It is a list of label selector requirements. The requirements are ANDed. It is a map of key-value pairs. A single key-value in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. :param pulumi.Input[str] key: It is the label key that the selector applies to.         :param pulumi.Input[str] operator: It represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.         :param pulumi.Input[Sequence[pulumi.Input[str]]] values: It is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. It is the label key that the selector applies to. It represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. It is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. Details of the storage used by the storage driver.         :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: List of devices to be used by the storage driver.         :param pulumi.Input[bool] force_use_disks: Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.         :param pulumi.Input[str] journal_device: Device used for journaling.         :param pulumi.Input[str] kvdb_device: Device used for internal KVDB.         :param pulumi.Input[str] system_metadata_device: Device that will be used to store system metadata by the driver.         :param pulumi.Input[bool] use_all: Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.         :param pulumi.Input[bool] use_all_with_partitions: Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty. List of devices to be used by the storage driver. Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using. Device used for journaling. Device used for internal KVDB. Device that will be used to store system metadata by the driver. Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty. Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty. Describes placement configuration for the storage cluster pods.         :param pulumi.Input['StorageClusterSpecPlacementNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecPlacementTolerationsArgs']]] tolerations: Tolerations for all the pods deployed by the StorageCluster controller. The pod with this toleration attached will tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>. Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods. Tolerations for all the pods deployed by the StorageCluster controller. The pod with this toleration attached will tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>. Describes node affinity scheduling rules for the storage cluster pods. This is exactly the same object as Kubernetes node affinity for pods. :param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.         :param pulumi.Input[str] key: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.         :param pulumi.Input[str] operator: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.         :param pulumi.Input[int] toleration_seconds: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.         :param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. Details of the storage used by the storage driver.         :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: List of devices to be used by the storage driver.         :param pulumi.Input[bool] force_use_disks: Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using.         :param pulumi.Input[str] journal_device: Device used for journaling.         :param pulumi.Input[str] kvdb_device: Device used for internal KVDB.         :param pulumi.Input[str] system_metadata_device: Device that will be used to store system metadata by the driver.         :param pulumi.Input[bool] use_all: Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty.         :param pulumi.Input[bool] use_all_with_partitions: Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty. List of devices to be used by the storage driver. Flag indicating to use the devices even if there is file system present on it. Note that the devices may be wiped before using. Device used for journaling. Device used for internal KVDB. Device that will be used to store system metadata by the driver. Use all available, unformatted, unpartitioned devices. This will be ignored if spec.storage.devices is not empty. Use all available unformatted devices. This will be ignored if spec.storage.devices is not empty. Contains STORK related spec.         :param pulumi.Input[Mapping[str, Any]] args: It is map of arguments given to STORK. Example: driver: pxd         :param pulumi.Input[bool] enabled: Flag indicating whether STORK needs to be enabled.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecStorkEnvArgs']]] env: List of environment variables used by STORK. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.         :param pulumi.Input[str] image: Docker image of the STORK container.         :param pulumi.Input[bool] lock_image: Flag indicating if the STORK image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades. It is map of arguments given to STORK. Example: driver: pxd Flag indicating whether STORK needs to be enabled. List of environment variables used by STORK. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Docker image of the STORK container. Flag indicating if the STORK image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades. An update strategy to replace existing StorageCluster pods with new pods.         :param pulumi.Input['StorageClusterSpecUpdateStrategyRollingUpdateArgs'] rolling_update: Spec to control the desired behavior of storage cluster rolling update.         :param pulumi.Input[str] type: Type of storage cluster update. Can be RollingUpdate or OnDelete. Default is RollingUpdate. Spec to control the desired behavior of storage cluster rolling update. Type of storage cluster update. Can be RollingUpdate or OnDelete. Default is RollingUpdate. Spec to control the desired behavior of storage cluster rolling update.         :param pulumi.Input[Union[int, str]] max_unavailable: The maximum number of StorageCluster pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of StorageCluster pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the storage pod can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those StorageCluster pods and then brings up new StorageCluster pods in their place. Once the new pods are available, it then proceeds onto other StorageCluster pods, thus ensuring that at least 70% of original number of StorageCluster pods are available at all times during the update. The maximum number of StorageCluster pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of StorageCluster pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the storage pod can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those StorageCluster pods and then brings up new StorageCluster pods in their place. Once the new pods are available, it then proceeds onto other StorageCluster pods, thus ensuring that at least 70% of original number of StorageCluster pods are available at all times during the update. Contains spec of a user interface for the storage driver.         :param pulumi.Input[bool] enabled: Flag indicating whether the user interface needs to be enabled.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterSpecUserInterfaceEnvArgs']]] env: List of environment variables used by the UI components. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret.         :param pulumi.Input[str] image: Docker image of the user interface container.         :param pulumi.Input[bool] lock_image: Flag indicating if the user interface image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades. Flag indicating whether the user interface needs to be enabled. List of environment variables used by the UI components. This is an array of Kubernetes EnvVar where the value can be given directly or from a source like field, config map or secret. Docker image of the user interface container. Flag indicating if the user interface image needs to be locked to the given image. If the image is not locked, it can be updated by the storage driver during upgrades. Most recently observed status of the storage cluster. This data may not be up to date.         :param pulumi.Input[str] cluster_name: Name of the storage cluster.         :param pulumi.Input[str] cluster_uid: Unique ID of the storage cluster.         :param pulumi.Input[int] collision_count: Count of hash collisions for the StorageCluster. The StorageCluster controller uses this field as a collision avoidance mechanism when it needs to create the name of the newest ControllerRevision.         :param pulumi.Input[Sequence[pulumi.Input['StorageClusterStatusConditionsArgs']]] conditions: Contains details for the current condition of this cluster.         :param pulumi.Input[str] phase: Phase of the StorageCluster is a simple, high-level summary of where the StorageCluster is in its lifecycle. The condition array contains more detailed information about the state of the cluster.         :param pulumi.Input['StorageClusterStatusStorageArgs'] storage: Contains details of storage in the cluster. Name of the storage cluster. Unique ID of the storage cluster. Count of hash collisions for the StorageCluster. The StorageCluster controller uses this field as a collision avoidance mechanism when it needs to create the name of the newest ControllerRevision. Contains details for the current condition of this cluster. Phase of the StorageCluster is a simple, high-level summary of where the StorageCluster is in its lifecycle. The condition array contains more detailed information about the state of the cluster. Contains details of storage in the cluster. :param pulumi.Input[str] reason: Reason is human readable message indicating details about the current state of the cluster.         :param pulumi.Input[str] status: Status of the condition.         :param pulumi.Input[str] type: Type of the condition. Reason is human readable message indicating details about the current state of the cluster. Status of the condition. Type of the condition. Contains details of storage in the cluster.         :param pulumi.Input[int] storage_nodes_per_zone: The number of storage nodes per zone in the cluster. The number of storage nodes per zone in the cluster. The desired behavior of the storage node. Currently changing the spec does not affect the actual storage node in the cluster. Eventually spec in StorageNode will override the spec from StorageCluster so that configuration can be overridden at node level.         :param pulumi.Input['StorageNodeSpecCloudStorageArgs'] cloud_storage: Details of storage on the node for cloud environments.         :param pulumi.Input[str] version: Version of the storage driver on the node. Details of storage on the node for cloud environments. Version of the storage driver on the node. Details of storage on the node for cloud environments.         :param pulumi.Input[Sequence[pulumi.Input['StorageNodeSpecCloudStorageDriveConfigsArgs']]] drive_configs: List of cloud drive configs for the storage node. List of cloud drive configs for the storage node. :param pulumi.Input[int] iops: IOPS required from the cloud drive.         :param pulumi.Input[Mapping[str, Any]] options: Additional options for the cloud drive.         :param pulumi.Input[int] size_in_gi_b: Size of cloud drive in GiB.         :param pulumi.Input[str] type: Type of cloud drive. IOPS required from the cloud drive. Additional options for the cloud drive. Size of cloud drive in GiB. Type of cloud drive. Most recently observed status of the storage node. The data may not be up to date.         :param pulumi.Input[Sequence[pulumi.Input['StorageNodeStatusConditionsArgs']]] conditions: Contains details for the current condition of this storage node.         :param pulumi.Input['StorageNodeStatusGeographyArgs'] geography: Contains topology information for the storage node.         :param pulumi.Input[str] node_uid: Unique ID of the storage node.         :param pulumi.Input[str] phase: Phase of the StorageNode is a simple, high-level summary of where the StorageNode is in its lifecycle. The condition array contains more detailed information about the state of the node. Contains details for the current condition of this storage node. Contains topology information for the storage node. Unique ID of the storage node. Phase of the StorageNode is a simple, high-level summary of where the StorageNode is in its lifecycle. The condition array contains more detailed information about the state of the node. :param pulumi.Input[str] reason: Reason is the human readable message indicating details about the current state of the cluster.         :param pulumi.Input[str] status: Status of the condition.         :param pulumi.Input[str] type: Type of the condition. Reason is the human readable message indicating details about the current state of the cluster. Status of the condition. Type of the condition. Contains topology information for the storage node.         :param pulumi.Input[str] rack: Rack on which the storage node is placed.         :param pulumi.Input[str] region: Region in which the storage node is placed.         :param pulumi.Input[str] zone: Zone in which the storage node is placed. Rack on which the storage node is placed. Region in which the storage node is placed. Zone in which the storage node is placed. :param pulumi.Input[str] data_ip: IP address used by the storage driver for data traffic.         :param pulumi.Input[str] mgmt_ip: IP address used by the storage driver for management traffic. IP address used by the storage driver for data traffic. IP address used by the storage driver for management traffic.