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

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

__all__ = [
    'HBaseClusterComponentVersion',
    'HBaseClusterGateway',
    'HBaseClusterMetastores',
    'HBaseClusterMetastoresAmbari',
    'HBaseClusterMetastoresHive',
    'HBaseClusterMetastoresOozie',
    'HBaseClusterMonitor',
    'HBaseClusterRoles',
    'HBaseClusterRolesHeadNode',
    'HBaseClusterRolesWorkerNode',
    'HBaseClusterRolesWorkerNodeAutoscale',
    'HBaseClusterRolesWorkerNodeAutoscaleRecurrence',
    'HBaseClusterRolesWorkerNodeAutoscaleRecurrenceSchedule',
    'HBaseClusterRolesZookeeperNode',
    'HBaseClusterStorageAccount',
    'HBaseClusterStorageAccountGen2',
    'HadoopClusterComponentVersion',
    'HadoopClusterGateway',
    'HadoopClusterMetastores',
    'HadoopClusterMetastoresAmbari',
    'HadoopClusterMetastoresHive',
    'HadoopClusterMetastoresOozie',
    'HadoopClusterMonitor',
    'HadoopClusterNetwork',
    'HadoopClusterRoles',
    'HadoopClusterRolesEdgeNode',
    'HadoopClusterRolesEdgeNodeInstallScriptAction',
    'HadoopClusterRolesHeadNode',
    'HadoopClusterRolesWorkerNode',
    'HadoopClusterRolesWorkerNodeAutoscale',
    'HadoopClusterRolesWorkerNodeAutoscaleCapacity',
    'HadoopClusterRolesWorkerNodeAutoscaleRecurrence',
    'HadoopClusterRolesWorkerNodeAutoscaleRecurrenceSchedule',
    'HadoopClusterRolesZookeeperNode',
    'HadoopClusterStorageAccount',
    'HadoopClusterStorageAccountGen2',
    'InteractiveQueryClusterComponentVersion',
    'InteractiveQueryClusterGateway',
    'InteractiveQueryClusterMetastores',
    'InteractiveQueryClusterMetastoresAmbari',
    'InteractiveQueryClusterMetastoresHive',
    'InteractiveQueryClusterMetastoresOozie',
    'InteractiveQueryClusterMonitor',
    'InteractiveQueryClusterNetwork',
    'InteractiveQueryClusterRoles',
    'InteractiveQueryClusterRolesHeadNode',
    'InteractiveQueryClusterRolesWorkerNode',
    'InteractiveQueryClusterRolesWorkerNodeAutoscale',
    'InteractiveQueryClusterRolesWorkerNodeAutoscaleCapacity',
    'InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrence',
    'InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrenceSchedule',
    'InteractiveQueryClusterRolesZookeeperNode',
    'InteractiveQueryClusterStorageAccount',
    'InteractiveQueryClusterStorageAccountGen2',
    'KafkaClusterComponentVersion',
    'KafkaClusterGateway',
    'KafkaClusterMetastores',
    'KafkaClusterMetastoresAmbari',
    'KafkaClusterMetastoresHive',
    'KafkaClusterMetastoresOozie',
    'KafkaClusterMonitor',
    'KafkaClusterRestProxy',
    'KafkaClusterRoles',
    'KafkaClusterRolesHeadNode',
    'KafkaClusterRolesKafkaManagementNode',
    'KafkaClusterRolesWorkerNode',
    'KafkaClusterRolesZookeeperNode',
    'KafkaClusterStorageAccount',
    'KafkaClusterStorageAccountGen2',
    'MLServicesClusterGateway',
    'MLServicesClusterRoles',
    'MLServicesClusterRolesEdgeNode',
    'MLServicesClusterRolesHeadNode',
    'MLServicesClusterRolesWorkerNode',
    'MLServicesClusterRolesZookeeperNode',
    'MLServicesClusterStorageAccount',
    'RServerClusterGateway',
    'RServerClusterRoles',
    'RServerClusterRolesEdgeNode',
    'RServerClusterRolesHeadNode',
    'RServerClusterRolesWorkerNode',
    'RServerClusterRolesZookeeperNode',
    'RServerClusterStorageAccount',
    'SparkClusterComponentVersion',
    'SparkClusterGateway',
    'SparkClusterMetastores',
    'SparkClusterMetastoresAmbari',
    'SparkClusterMetastoresHive',
    'SparkClusterMetastoresOozie',
    'SparkClusterMonitor',
    'SparkClusterNetwork',
    'SparkClusterRoles',
    'SparkClusterRolesHeadNode',
    'SparkClusterRolesWorkerNode',
    'SparkClusterRolesWorkerNodeAutoscale',
    'SparkClusterRolesWorkerNodeAutoscaleCapacity',
    'SparkClusterRolesWorkerNodeAutoscaleRecurrence',
    'SparkClusterRolesWorkerNodeAutoscaleRecurrenceSchedule',
    'SparkClusterRolesZookeeperNode',
    'SparkClusterStorageAccount',
    'SparkClusterStorageAccountGen2',
    'StormClusterComponentVersion',
    'StormClusterGateway',
    'StormClusterMetastores',
    'StormClusterMetastoresAmbari',
    'StormClusterMetastoresHive',
    'StormClusterMetastoresOozie',
    'StormClusterMonitor',
    'StormClusterRoles',
    'StormClusterRolesHeadNode',
    'StormClusterRolesWorkerNode',
    'StormClusterRolesZookeeperNode',
    'StormClusterStorageAccount',
    'GetClusterGatewayResult',
]

@pulumi.output_type
class HBaseClusterComponentVersion(dict):
    def __init__(__self__, *,
                 hbase: str):
        """
        :param str hbase: The version of HBase which should be used for this HDInsight HBase Cluster. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "hbase", hbase)

    @property
    @pulumi.getter
    def hbase(self) -> str:
        """
        The version of HBase which should be used for this HDInsight HBase Cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "hbase")


@pulumi.output_type
class HBaseClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class HBaseClusterMetastores(dict):
    def __init__(__self__, *,
                 ambari: Optional['outputs.HBaseClusterMetastoresAmbari'] = None,
                 hive: Optional['outputs.HBaseClusterMetastoresHive'] = None,
                 oozie: Optional['outputs.HBaseClusterMetastoresOozie'] = None):
        """
        :param 'HBaseClusterMetastoresAmbariArgs' ambari: An `ambari` block as defined below.
        :param 'HBaseClusterMetastoresHiveArgs' hive: A `hive` block as defined below.
        :param 'HBaseClusterMetastoresOozieArgs' oozie: An `oozie` block as defined below.
        """
        if ambari is not None:
            pulumi.set(__self__, "ambari", ambari)
        if hive is not None:
            pulumi.set(__self__, "hive", hive)
        if oozie is not None:
            pulumi.set(__self__, "oozie", oozie)

    @property
    @pulumi.getter
    def ambari(self) -> Optional['outputs.HBaseClusterMetastoresAmbari']:
        """
        An `ambari` block as defined below.
        """
        return pulumi.get(self, "ambari")

    @property
    @pulumi.getter
    def hive(self) -> Optional['outputs.HBaseClusterMetastoresHive']:
        """
        A `hive` block as defined below.
        """
        return pulumi.get(self, "hive")

    @property
    @pulumi.getter
    def oozie(self) -> Optional['outputs.HBaseClusterMetastoresOozie']:
        """
        An `oozie` block as defined below.
        """
        return pulumi.get(self, "oozie")


@pulumi.output_type
class HBaseClusterMetastoresAmbari(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        :param str username: The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HBaseClusterMetastoresHive(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        :param str username: The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HBaseClusterMetastoresOozie(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        :param str username: The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HBaseClusterMonitor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "primaryKey":
            suggest = "primary_key"

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

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

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

    def __init__(__self__, *,
                 log_analytics_workspace_id: str,
                 primary_key: str):
        """
        :param str log_analytics_workspace_id: The Operations Management Suite (OMS) workspace ID.
        :param str primary_key: The Operations Management Suite (OMS) workspace key.
        """
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "primary_key", primary_key)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The Operations Management Suite (OMS) workspace ID.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> str:
        """
        The Operations Management Suite (OMS) workspace key.
        """
        return pulumi.get(self, "primary_key")


@pulumi.output_type
class HBaseClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"

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

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

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

    def __init__(__self__, *,
                 head_node: 'outputs.HBaseClusterRolesHeadNode',
                 worker_node: 'outputs.HBaseClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.HBaseClusterRolesZookeeperNode'):
        """
        :param 'HBaseClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'HBaseClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'HBaseClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        """
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.HBaseClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.HBaseClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.HBaseClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")


@pulumi.output_type
class HBaseClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class HBaseClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 autoscale: Optional['outputs.HBaseClusterRolesWorkerNodeAutoscale'] = None,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param 'HBaseClusterRolesWorkerNodeAutoscaleArgs' autoscale: A `autoscale` block as defined below.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if autoscale is not None:
            pulumi.set(__self__, "autoscale", autoscale)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def autoscale(self) -> Optional['outputs.HBaseClusterRolesWorkerNodeAutoscale']:
        """
        A `autoscale` block as defined below.
        """
        return pulumi.get(self, "autoscale")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class HBaseClusterRolesWorkerNodeAutoscale(dict):
    def __init__(__self__, *,
                 recurrence: Optional['outputs.HBaseClusterRolesWorkerNodeAutoscaleRecurrence'] = None):
        """
        :param 'HBaseClusterRolesWorkerNodeAutoscaleRecurrenceArgs' recurrence: A `recurrence` block as defined below.
        """
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)

    @property
    @pulumi.getter
    def recurrence(self) -> Optional['outputs.HBaseClusterRolesWorkerNodeAutoscaleRecurrence']:
        """
        A `recurrence` block as defined below.
        """
        return pulumi.get(self, "recurrence")


@pulumi.output_type
class HBaseClusterRolesWorkerNodeAutoscaleRecurrence(dict):
    def __init__(__self__, *,
                 schedules: Sequence['outputs.HBaseClusterRolesWorkerNodeAutoscaleRecurrenceSchedule'],
                 timezone: str):
        """
        :param Sequence['HBaseClusterRolesWorkerNodeAutoscaleRecurrenceScheduleArgs'] schedules: A list of `schedule` blocks as defined below.
        :param str timezone: The time zone for the autoscale schedule times.
        """
        pulumi.set(__self__, "schedules", schedules)
        pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter
    def schedules(self) -> Sequence['outputs.HBaseClusterRolesWorkerNodeAutoscaleRecurrenceSchedule']:
        """
        A list of `schedule` blocks as defined below.
        """
        return pulumi.get(self, "schedules")

    @property
    @pulumi.getter
    def timezone(self) -> str:
        """
        The time zone for the autoscale schedule times.
        """
        return pulumi.get(self, "timezone")


@pulumi.output_type
class HBaseClusterRolesWorkerNodeAutoscaleRecurrenceSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"

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

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

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

    def __init__(__self__, *,
                 days: Sequence[str],
                 target_instance_count: int,
                 time: str):
        """
        :param Sequence[str] days: The days of the week to perform autoscale.
        :param int target_instance_count: The number of worker nodes to autoscale at the specified time.
        :param str time: The time of day to perform the autoscale in 24hour format.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "time", time)

    @property
    @pulumi.getter
    def days(self) -> Sequence[str]:
        """
        The days of the week to perform autoscale.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of worker nodes to autoscale at the specified time.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def time(self) -> str:
        """
        The time of day to perform the autoscale in 24hour format.
        """
        return pulumi.get(self, "time")


@pulumi.output_type
class HBaseClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class HBaseClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class HBaseClusterStorageAccountGen2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filesystemId":
            suggest = "filesystem_id"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "managedIdentityResourceId":
            suggest = "managed_identity_resource_id"
        elif key == "storageResourceId":
            suggest = "storage_resource_id"

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

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

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

    def __init__(__self__, *,
                 filesystem_id: str,
                 is_default: bool,
                 managed_identity_resource_id: str,
                 storage_resource_id: str):
        """
        :param str filesystem_id: The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str managed_identity_resource_id: The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        :param str storage_resource_id: The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "filesystem_id", filesystem_id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "managed_identity_resource_id", managed_identity_resource_id)
        pulumi.set(__self__, "storage_resource_id", storage_resource_id)

    @property
    @pulumi.getter(name="filesystemId")
    def filesystem_id(self) -> str:
        """
        The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "filesystem_id")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="managedIdentityResourceId")
    def managed_identity_resource_id(self) -> str:
        """
        The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "managed_identity_resource_id")

    @property
    @pulumi.getter(name="storageResourceId")
    def storage_resource_id(self) -> str:
        """
        The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_resource_id")


@pulumi.output_type
class HadoopClusterComponentVersion(dict):
    def __init__(__self__, *,
                 hadoop: str):
        """
        :param str hadoop: The version of Hadoop which should be used for this HDInsight Hadoop Cluster. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "hadoop", hadoop)

    @property
    @pulumi.getter
    def hadoop(self) -> str:
        """
        The version of Hadoop which should be used for this HDInsight Hadoop Cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "hadoop")


@pulumi.output_type
class HadoopClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class HadoopClusterMetastores(dict):
    def __init__(__self__, *,
                 ambari: Optional['outputs.HadoopClusterMetastoresAmbari'] = None,
                 hive: Optional['outputs.HadoopClusterMetastoresHive'] = None,
                 oozie: Optional['outputs.HadoopClusterMetastoresOozie'] = None):
        """
        :param 'HadoopClusterMetastoresAmbariArgs' ambari: An `ambari` block as defined below.
        :param 'HadoopClusterMetastoresHiveArgs' hive: A `hive` block as defined below.
        :param 'HadoopClusterMetastoresOozieArgs' oozie: An `oozie` block as defined below.
        """
        if ambari is not None:
            pulumi.set(__self__, "ambari", ambari)
        if hive is not None:
            pulumi.set(__self__, "hive", hive)
        if oozie is not None:
            pulumi.set(__self__, "oozie", oozie)

    @property
    @pulumi.getter
    def ambari(self) -> Optional['outputs.HadoopClusterMetastoresAmbari']:
        """
        An `ambari` block as defined below.
        """
        return pulumi.get(self, "ambari")

    @property
    @pulumi.getter
    def hive(self) -> Optional['outputs.HadoopClusterMetastoresHive']:
        """
        A `hive` block as defined below.
        """
        return pulumi.get(self, "hive")

    @property
    @pulumi.getter
    def oozie(self) -> Optional['outputs.HadoopClusterMetastoresOozie']:
        """
        An `oozie` block as defined below.
        """
        return pulumi.get(self, "oozie")


@pulumi.output_type
class HadoopClusterMetastoresAmbari(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        :param str username: The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HadoopClusterMetastoresHive(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        :param str username: The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HadoopClusterMetastoresOozie(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        :param str username: The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HadoopClusterMonitor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "primaryKey":
            suggest = "primary_key"

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

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

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

    def __init__(__self__, *,
                 log_analytics_workspace_id: str,
                 primary_key: str):
        """
        :param str log_analytics_workspace_id: The Operations Management Suite (OMS) workspace ID.
        :param str primary_key: The Operations Management Suite (OMS) workspace key.
        """
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "primary_key", primary_key)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The Operations Management Suite (OMS) workspace ID.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> str:
        """
        The Operations Management Suite (OMS) workspace key.
        """
        return pulumi.get(self, "primary_key")


@pulumi.output_type
class HadoopClusterNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionDirection":
            suggest = "connection_direction"
        elif key == "privateLinkEnabled":
            suggest = "private_link_enabled"

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

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

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

    def __init__(__self__, *,
                 connection_direction: Optional[str] = None,
                 private_link_enabled: Optional[bool] = None):
        """
        :param str connection_direction: The direction of the resource provider connection. Possible values include `Inbound` or `Outbound`. Defaults to `Inbound`. Changing this forces a new resource to be created.
        :param bool private_link_enabled: Is the private link enabled? Possible values include `True` or `False`. Defaults to `False`. Changing this forces a new resource to be created.
        """
        if connection_direction is not None:
            pulumi.set(__self__, "connection_direction", connection_direction)
        if private_link_enabled is not None:
            pulumi.set(__self__, "private_link_enabled", private_link_enabled)

    @property
    @pulumi.getter(name="connectionDirection")
    def connection_direction(self) -> Optional[str]:
        """
        The direction of the resource provider connection. Possible values include `Inbound` or `Outbound`. Defaults to `Inbound`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "connection_direction")

    @property
    @pulumi.getter(name="privateLinkEnabled")
    def private_link_enabled(self) -> Optional[bool]:
        """
        Is the private link enabled? Possible values include `True` or `False`. Defaults to `False`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "private_link_enabled")


@pulumi.output_type
class HadoopClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"
        elif key == "edgeNode":
            suggest = "edge_node"

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

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

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

    def __init__(__self__, *,
                 head_node: 'outputs.HadoopClusterRolesHeadNode',
                 worker_node: 'outputs.HadoopClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.HadoopClusterRolesZookeeperNode',
                 edge_node: Optional['outputs.HadoopClusterRolesEdgeNode'] = None):
        """
        :param 'HadoopClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'HadoopClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'HadoopClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        :param 'HadoopClusterRolesEdgeNodeArgs' edge_node: A `edge_node` block as defined below.
        """
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)
        if edge_node is not None:
            pulumi.set(__self__, "edge_node", edge_node)

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.HadoopClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.HadoopClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.HadoopClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")

    @property
    @pulumi.getter(name="edgeNode")
    def edge_node(self) -> Optional['outputs.HadoopClusterRolesEdgeNode']:
        """
        A `edge_node` block as defined below.
        """
        return pulumi.get(self, "edge_node")


@pulumi.output_type
class HadoopClusterRolesEdgeNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "installScriptActions":
            suggest = "install_script_actions"
        elif key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"

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

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

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

    def __init__(__self__, *,
                 install_script_actions: Sequence['outputs.HadoopClusterRolesEdgeNodeInstallScriptAction'],
                 target_instance_count: int,
                 vm_size: str):
        """
        :param Sequence['HadoopClusterRolesEdgeNodeInstallScriptActionArgs'] install_script_actions: A `install_script_action` block as defined below.
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Edge Nodes. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "install_script_actions", install_script_actions)
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "vm_size", vm_size)

    @property
    @pulumi.getter(name="installScriptActions")
    def install_script_actions(self) -> Sequence['outputs.HadoopClusterRolesEdgeNodeInstallScriptAction']:
        """
        A `install_script_action` block as defined below.
        """
        return pulumi.get(self, "install_script_actions")

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Edge Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")


@pulumi.output_type
class HadoopClusterRolesEdgeNodeInstallScriptAction(dict):
    def __init__(__self__, *,
                 name: str,
                 uri: str):
        """
        :param str name: The name of the install script action. Changing this forces a new resource to be created.
        :param str uri: The URI pointing to the script to run during the installation of the edge node. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the install script action. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI pointing to the script to run during the installation of the edge node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class HadoopClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class HadoopClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 autoscale: Optional['outputs.HadoopClusterRolesWorkerNodeAutoscale'] = None,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param 'HadoopClusterRolesWorkerNodeAutoscaleArgs' autoscale: A `autoscale` block as defined below.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if autoscale is not None:
            pulumi.set(__self__, "autoscale", autoscale)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def autoscale(self) -> Optional['outputs.HadoopClusterRolesWorkerNodeAutoscale']:
        """
        A `autoscale` block as defined below.
        """
        return pulumi.get(self, "autoscale")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class HadoopClusterRolesWorkerNodeAutoscale(dict):
    def __init__(__self__, *,
                 capacity: Optional['outputs.HadoopClusterRolesWorkerNodeAutoscaleCapacity'] = None,
                 recurrence: Optional['outputs.HadoopClusterRolesWorkerNodeAutoscaleRecurrence'] = None):
        """
        :param 'HadoopClusterRolesWorkerNodeAutoscaleCapacityArgs' capacity: A `capacity` block as defined below.
        :param 'HadoopClusterRolesWorkerNodeAutoscaleRecurrenceArgs' recurrence: A `recurrence` block as defined below.
        """
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)

    @property
    @pulumi.getter
    def capacity(self) -> Optional['outputs.HadoopClusterRolesWorkerNodeAutoscaleCapacity']:
        """
        A `capacity` block as defined below.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def recurrence(self) -> Optional['outputs.HadoopClusterRolesWorkerNodeAutoscaleRecurrence']:
        """
        A `recurrence` block as defined below.
        """
        return pulumi.get(self, "recurrence")


@pulumi.output_type
class HadoopClusterRolesWorkerNodeAutoscaleCapacity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxInstanceCount":
            suggest = "max_instance_count"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"

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

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

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

    def __init__(__self__, *,
                 max_instance_count: int,
                 min_instance_count: int):
        """
        :param int max_instance_count: The maximum number of worker nodes to autoscale to based on the cluster's activity.
        :param int min_instance_count: The minimum number of worker nodes to autoscale to based on the cluster's activity.
        """
        pulumi.set(__self__, "max_instance_count", max_instance_count)
        pulumi.set(__self__, "min_instance_count", min_instance_count)

    @property
    @pulumi.getter(name="maxInstanceCount")
    def max_instance_count(self) -> int:
        """
        The maximum number of worker nodes to autoscale to based on the cluster's activity.
        """
        return pulumi.get(self, "max_instance_count")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> int:
        """
        The minimum number of worker nodes to autoscale to based on the cluster's activity.
        """
        return pulumi.get(self, "min_instance_count")


@pulumi.output_type
class HadoopClusterRolesWorkerNodeAutoscaleRecurrence(dict):
    def __init__(__self__, *,
                 schedules: Sequence['outputs.HadoopClusterRolesWorkerNodeAutoscaleRecurrenceSchedule'],
                 timezone: str):
        """
        :param Sequence['HadoopClusterRolesWorkerNodeAutoscaleRecurrenceScheduleArgs'] schedules: A list of `schedule` blocks as defined below.
        :param str timezone: The time zone for the autoscale schedule times.
        """
        pulumi.set(__self__, "schedules", schedules)
        pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter
    def schedules(self) -> Sequence['outputs.HadoopClusterRolesWorkerNodeAutoscaleRecurrenceSchedule']:
        """
        A list of `schedule` blocks as defined below.
        """
        return pulumi.get(self, "schedules")

    @property
    @pulumi.getter
    def timezone(self) -> str:
        """
        The time zone for the autoscale schedule times.
        """
        return pulumi.get(self, "timezone")


@pulumi.output_type
class HadoopClusterRolesWorkerNodeAutoscaleRecurrenceSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"

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

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

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

    def __init__(__self__, *,
                 days: Sequence[str],
                 target_instance_count: int,
                 time: str):
        """
        :param Sequence[str] days: The days of the week to perform autoscale.
        :param int target_instance_count: The number of worker nodes to autoscale at the specified time.
        :param str time: The time of day to perform the autoscale in 24hour format.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "time", time)

    @property
    @pulumi.getter
    def days(self) -> Sequence[str]:
        """
        The days of the week to perform autoscale.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of worker nodes to autoscale at the specified time.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def time(self) -> str:
        """
        The time of day to perform the autoscale in 24hour format.
        """
        return pulumi.get(self, "time")


@pulumi.output_type
class HadoopClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class HadoopClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class HadoopClusterStorageAccountGen2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filesystemId":
            suggest = "filesystem_id"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "managedIdentityResourceId":
            suggest = "managed_identity_resource_id"
        elif key == "storageResourceId":
            suggest = "storage_resource_id"

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

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

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

    def __init__(__self__, *,
                 filesystem_id: str,
                 is_default: bool,
                 managed_identity_resource_id: str,
                 storage_resource_id: str):
        """
        :param str filesystem_id: The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str managed_identity_resource_id: The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        :param str storage_resource_id: The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "filesystem_id", filesystem_id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "managed_identity_resource_id", managed_identity_resource_id)
        pulumi.set(__self__, "storage_resource_id", storage_resource_id)

    @property
    @pulumi.getter(name="filesystemId")
    def filesystem_id(self) -> str:
        """
        The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "filesystem_id")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="managedIdentityResourceId")
    def managed_identity_resource_id(self) -> str:
        """
        The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "managed_identity_resource_id")

    @property
    @pulumi.getter(name="storageResourceId")
    def storage_resource_id(self) -> str:
        """
        The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_resource_id")


@pulumi.output_type
class InteractiveQueryClusterComponentVersion(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interactiveHive":
            suggest = "interactive_hive"

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

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

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

    def __init__(__self__, *,
                 interactive_hive: str):
        pulumi.set(__self__, "interactive_hive", interactive_hive)

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


@pulumi.output_type
class InteractiveQueryClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class InteractiveQueryClusterMetastores(dict):
    def __init__(__self__, *,
                 ambari: Optional['outputs.InteractiveQueryClusterMetastoresAmbari'] = None,
                 hive: Optional['outputs.InteractiveQueryClusterMetastoresHive'] = None,
                 oozie: Optional['outputs.InteractiveQueryClusterMetastoresOozie'] = None):
        """
        :param 'InteractiveQueryClusterMetastoresAmbariArgs' ambari: An `ambari` block as defined below.
        :param 'InteractiveQueryClusterMetastoresHiveArgs' hive: A `hive` block as defined below.
        :param 'InteractiveQueryClusterMetastoresOozieArgs' oozie: An `oozie` block as defined below.
        """
        if ambari is not None:
            pulumi.set(__self__, "ambari", ambari)
        if hive is not None:
            pulumi.set(__self__, "hive", hive)
        if oozie is not None:
            pulumi.set(__self__, "oozie", oozie)

    @property
    @pulumi.getter
    def ambari(self) -> Optional['outputs.InteractiveQueryClusterMetastoresAmbari']:
        """
        An `ambari` block as defined below.
        """
        return pulumi.get(self, "ambari")

    @property
    @pulumi.getter
    def hive(self) -> Optional['outputs.InteractiveQueryClusterMetastoresHive']:
        """
        A `hive` block as defined below.
        """
        return pulumi.get(self, "hive")

    @property
    @pulumi.getter
    def oozie(self) -> Optional['outputs.InteractiveQueryClusterMetastoresOozie']:
        """
        An `oozie` block as defined below.
        """
        return pulumi.get(self, "oozie")


@pulumi.output_type
class InteractiveQueryClusterMetastoresAmbari(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        :param str username: The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class InteractiveQueryClusterMetastoresHive(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        :param str username: The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class InteractiveQueryClusterMetastoresOozie(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        :param str username: The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class InteractiveQueryClusterMonitor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "primaryKey":
            suggest = "primary_key"

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

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

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

    def __init__(__self__, *,
                 log_analytics_workspace_id: str,
                 primary_key: str):
        """
        :param str log_analytics_workspace_id: The Operations Management Suite (OMS) workspace ID.
        :param str primary_key: The Operations Management Suite (OMS) workspace key.
        """
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "primary_key", primary_key)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The Operations Management Suite (OMS) workspace ID.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> str:
        """
        The Operations Management Suite (OMS) workspace key.
        """
        return pulumi.get(self, "primary_key")


@pulumi.output_type
class InteractiveQueryClusterNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionDirection":
            suggest = "connection_direction"
        elif key == "privateLinkEnabled":
            suggest = "private_link_enabled"

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

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

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

    def __init__(__self__, *,
                 connection_direction: Optional[str] = None,
                 private_link_enabled: Optional[bool] = None):
        """
        :param str connection_direction: The direction of the resource provider connection. Possible values include `Inbound` or `Outbound`. Defaults to `Inbound`. Changing this forces a new resource to be created.
        :param bool private_link_enabled: Is the private link enabled? Possible values include `True` or `False`. Defaults to `False`. Changing this forces a new resource to be created.
        """
        if connection_direction is not None:
            pulumi.set(__self__, "connection_direction", connection_direction)
        if private_link_enabled is not None:
            pulumi.set(__self__, "private_link_enabled", private_link_enabled)

    @property
    @pulumi.getter(name="connectionDirection")
    def connection_direction(self) -> Optional[str]:
        """
        The direction of the resource provider connection. Possible values include `Inbound` or `Outbound`. Defaults to `Inbound`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "connection_direction")

    @property
    @pulumi.getter(name="privateLinkEnabled")
    def private_link_enabled(self) -> Optional[bool]:
        """
        Is the private link enabled? Possible values include `True` or `False`. Defaults to `False`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "private_link_enabled")


@pulumi.output_type
class InteractiveQueryClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"

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

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

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

    def __init__(__self__, *,
                 head_node: 'outputs.InteractiveQueryClusterRolesHeadNode',
                 worker_node: 'outputs.InteractiveQueryClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.InteractiveQueryClusterRolesZookeeperNode'):
        """
        :param 'InteractiveQueryClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'InteractiveQueryClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'InteractiveQueryClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        """
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.InteractiveQueryClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.InteractiveQueryClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.InteractiveQueryClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")


@pulumi.output_type
class InteractiveQueryClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class InteractiveQueryClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 autoscale: Optional['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscale'] = None,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param 'InteractiveQueryClusterRolesWorkerNodeAutoscaleArgs' autoscale: A `autoscale` block as defined below.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if autoscale is not None:
            pulumi.set(__self__, "autoscale", autoscale)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def autoscale(self) -> Optional['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscale']:
        """
        A `autoscale` block as defined below.
        """
        return pulumi.get(self, "autoscale")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class InteractiveQueryClusterRolesWorkerNodeAutoscale(dict):
    def __init__(__self__, *,
                 capacity: Optional['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscaleCapacity'] = None,
                 recurrence: Optional['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrence'] = None):
        """
        :param 'InteractiveQueryClusterRolesWorkerNodeAutoscaleCapacityArgs' capacity: A `capacity` block as defined below.
        :param 'InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrenceArgs' recurrence: A `recurrence` block as defined below.
        """
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)

    @property
    @pulumi.getter
    def capacity(self) -> Optional['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscaleCapacity']:
        """
        A `capacity` block as defined below.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def recurrence(self) -> Optional['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrence']:
        """
        A `recurrence` block as defined below.
        """
        return pulumi.get(self, "recurrence")


@pulumi.output_type
class InteractiveQueryClusterRolesWorkerNodeAutoscaleCapacity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxInstanceCount":
            suggest = "max_instance_count"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"

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

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

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

    def __init__(__self__, *,
                 max_instance_count: int,
                 min_instance_count: int):
        """
        :param int max_instance_count: The maximum number of worker nodes to autoscale to based on the cluster's activity.
        :param int min_instance_count: The minimum number of worker nodes to autoscale to based on the cluster's activity.
        """
        pulumi.set(__self__, "max_instance_count", max_instance_count)
        pulumi.set(__self__, "min_instance_count", min_instance_count)

    @property
    @pulumi.getter(name="maxInstanceCount")
    def max_instance_count(self) -> int:
        """
        The maximum number of worker nodes to autoscale to based on the cluster's activity.
        """
        return pulumi.get(self, "max_instance_count")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> int:
        """
        The minimum number of worker nodes to autoscale to based on the cluster's activity.
        """
        return pulumi.get(self, "min_instance_count")


@pulumi.output_type
class InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrence(dict):
    def __init__(__self__, *,
                 schedules: Sequence['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrenceSchedule'],
                 timezone: str):
        """
        :param Sequence['InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrenceScheduleArgs'] schedules: A list of `schedule` blocks as defined below.
        :param str timezone: The time zone for the autoscale schedule times.
        """
        pulumi.set(__self__, "schedules", schedules)
        pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter
    def schedules(self) -> Sequence['outputs.InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrenceSchedule']:
        """
        A list of `schedule` blocks as defined below.
        """
        return pulumi.get(self, "schedules")

    @property
    @pulumi.getter
    def timezone(self) -> str:
        """
        The time zone for the autoscale schedule times.
        """
        return pulumi.get(self, "timezone")


@pulumi.output_type
class InteractiveQueryClusterRolesWorkerNodeAutoscaleRecurrenceSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"

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

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

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

    def __init__(__self__, *,
                 days: Sequence[str],
                 target_instance_count: int,
                 time: str):
        """
        :param Sequence[str] days: The days of the week to perform autoscale.
        :param int target_instance_count: The number of worker nodes to autoscale at the specified time.
        :param str time: The time of day to perform the autoscale in 24hour format.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "time", time)

    @property
    @pulumi.getter
    def days(self) -> Sequence[str]:
        """
        The days of the week to perform autoscale.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of worker nodes to autoscale at the specified time.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def time(self) -> str:
        """
        The time of day to perform the autoscale in 24hour format.
        """
        return pulumi.get(self, "time")


@pulumi.output_type
class InteractiveQueryClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class InteractiveQueryClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class InteractiveQueryClusterStorageAccountGen2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filesystemId":
            suggest = "filesystem_id"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "managedIdentityResourceId":
            suggest = "managed_identity_resource_id"
        elif key == "storageResourceId":
            suggest = "storage_resource_id"

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

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

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

    def __init__(__self__, *,
                 filesystem_id: str,
                 is_default: bool,
                 managed_identity_resource_id: str,
                 storage_resource_id: str):
        """
        :param str filesystem_id: The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str managed_identity_resource_id: The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        :param str storage_resource_id: The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "filesystem_id", filesystem_id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "managed_identity_resource_id", managed_identity_resource_id)
        pulumi.set(__self__, "storage_resource_id", storage_resource_id)

    @property
    @pulumi.getter(name="filesystemId")
    def filesystem_id(self) -> str:
        """
        The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "filesystem_id")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="managedIdentityResourceId")
    def managed_identity_resource_id(self) -> str:
        """
        The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "managed_identity_resource_id")

    @property
    @pulumi.getter(name="storageResourceId")
    def storage_resource_id(self) -> str:
        """
        The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_resource_id")


@pulumi.output_type
class KafkaClusterComponentVersion(dict):
    def __init__(__self__, *,
                 kafka: str):
        """
        :param str kafka: The version of Kafka which should be used for this HDInsight Kafka Cluster. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "kafka", kafka)

    @property
    @pulumi.getter
    def kafka(self) -> str:
        """
        The version of Kafka which should be used for this HDInsight Kafka Cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "kafka")


@pulumi.output_type
class KafkaClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class KafkaClusterMetastores(dict):
    def __init__(__self__, *,
                 ambari: Optional['outputs.KafkaClusterMetastoresAmbari'] = None,
                 hive: Optional['outputs.KafkaClusterMetastoresHive'] = None,
                 oozie: Optional['outputs.KafkaClusterMetastoresOozie'] = None):
        """
        :param 'KafkaClusterMetastoresAmbariArgs' ambari: An `ambari` block as defined below.
        :param 'KafkaClusterMetastoresHiveArgs' hive: A `hive` block as defined below.
        :param 'KafkaClusterMetastoresOozieArgs' oozie: An `oozie` block as defined below.
        """
        if ambari is not None:
            pulumi.set(__self__, "ambari", ambari)
        if hive is not None:
            pulumi.set(__self__, "hive", hive)
        if oozie is not None:
            pulumi.set(__self__, "oozie", oozie)

    @property
    @pulumi.getter
    def ambari(self) -> Optional['outputs.KafkaClusterMetastoresAmbari']:
        """
        An `ambari` block as defined below.
        """
        return pulumi.get(self, "ambari")

    @property
    @pulumi.getter
    def hive(self) -> Optional['outputs.KafkaClusterMetastoresHive']:
        """
        A `hive` block as defined below.
        """
        return pulumi.get(self, "hive")

    @property
    @pulumi.getter
    def oozie(self) -> Optional['outputs.KafkaClusterMetastoresOozie']:
        """
        An `oozie` block as defined below.
        """
        return pulumi.get(self, "oozie")


@pulumi.output_type
class KafkaClusterMetastoresAmbari(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        :param str username: The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class KafkaClusterMetastoresHive(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        :param str username: The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class KafkaClusterMetastoresOozie(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        :param str username: The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class KafkaClusterMonitor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "primaryKey":
            suggest = "primary_key"

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

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

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

    def __init__(__self__, *,
                 log_analytics_workspace_id: str,
                 primary_key: str):
        """
        :param str log_analytics_workspace_id: The Operations Management Suite (OMS) workspace ID.
        :param str primary_key: The Operations Management Suite (OMS) workspace key.
        """
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "primary_key", primary_key)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The Operations Management Suite (OMS) workspace ID.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> str:
        """
        The Operations Management Suite (OMS) workspace key.
        """
        return pulumi.get(self, "primary_key")


@pulumi.output_type
class KafkaClusterRestProxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroupId":
            suggest = "security_group_id"

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

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

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

    def __init__(__self__, *,
                 security_group_id: str):
        """
        :param str security_group_id: The Azure Active Directory Security Group ID.
        """
        pulumi.set(__self__, "security_group_id", security_group_id)

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> str:
        """
        The Azure Active Directory Security Group ID.
        """
        return pulumi.get(self, "security_group_id")


@pulumi.output_type
class KafkaClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"
        elif key == "kafkaManagementNode":
            suggest = "kafka_management_node"

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

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

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

    def __init__(__self__, *,
                 head_node: 'outputs.KafkaClusterRolesHeadNode',
                 worker_node: 'outputs.KafkaClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.KafkaClusterRolesZookeeperNode',
                 kafka_management_node: Optional['outputs.KafkaClusterRolesKafkaManagementNode'] = None):
        """
        :param 'KafkaClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'KafkaClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'KafkaClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        :param 'KafkaClusterRolesKafkaManagementNodeArgs' kafka_management_node: A `kafka_management_node` block as defined below.
        """
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)
        if kafka_management_node is not None:
            pulumi.set(__self__, "kafka_management_node", kafka_management_node)

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.KafkaClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.KafkaClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.KafkaClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")

    @property
    @pulumi.getter(name="kafkaManagementNode")
    def kafka_management_node(self) -> Optional['outputs.KafkaClusterRolesKafkaManagementNode']:
        """
        A `kafka_management_node` block as defined below.
        """
        return pulumi.get(self, "kafka_management_node")


@pulumi.output_type
class KafkaClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class KafkaClusterRolesKafkaManagementNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Kafka Management Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Kafka Management Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Kafka Management Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Kafka Management Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Kafka Management Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Kafka Management Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Kafka Management Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Kafka Management Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Kafka Management Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Kafka Management Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Kafka Management Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Kafka Management Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class KafkaClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numberOfDisksPerNode":
            suggest = "number_of_disks_per_node"
        elif key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 number_of_disks_per_node: int,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int number_of_disks_per_node: The number of Data Disks which should be assigned to each Worker Node, which can be between 1 and 8. Changing this forces a new resource to be created.
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "number_of_disks_per_node", number_of_disks_per_node)
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="numberOfDisksPerNode")
    def number_of_disks_per_node(self) -> int:
        """
        The number of Data Disks which should be assigned to each Worker Node, which can be between 1 and 8. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "number_of_disks_per_node")

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class KafkaClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class KafkaClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class KafkaClusterStorageAccountGen2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filesystemId":
            suggest = "filesystem_id"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "managedIdentityResourceId":
            suggest = "managed_identity_resource_id"
        elif key == "storageResourceId":
            suggest = "storage_resource_id"

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

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

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

    def __init__(__self__, *,
                 filesystem_id: str,
                 is_default: bool,
                 managed_identity_resource_id: str,
                 storage_resource_id: str):
        """
        :param str filesystem_id: The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str managed_identity_resource_id: The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        :param str storage_resource_id: The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "filesystem_id", filesystem_id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "managed_identity_resource_id", managed_identity_resource_id)
        pulumi.set(__self__, "storage_resource_id", storage_resource_id)

    @property
    @pulumi.getter(name="filesystemId")
    def filesystem_id(self) -> str:
        """
        The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "filesystem_id")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="managedIdentityResourceId")
    def managed_identity_resource_id(self) -> str:
        """
        The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "managed_identity_resource_id")

    @property
    @pulumi.getter(name="storageResourceId")
    def storage_resource_id(self) -> str:
        """
        The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_resource_id")


@pulumi.output_type
class MLServicesClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class MLServicesClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "edgeNode":
            suggest = "edge_node"
        elif key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"

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

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

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

    def __init__(__self__, *,
                 edge_node: 'outputs.MLServicesClusterRolesEdgeNode',
                 head_node: 'outputs.MLServicesClusterRolesHeadNode',
                 worker_node: 'outputs.MLServicesClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.MLServicesClusterRolesZookeeperNode'):
        """
        :param 'MLServicesClusterRolesEdgeNodeArgs' edge_node: A `edge_node` block as defined above.
        :param 'MLServicesClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'MLServicesClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'MLServicesClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        """
        pulumi.set(__self__, "edge_node", edge_node)
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)

    @property
    @pulumi.getter(name="edgeNode")
    def edge_node(self) -> 'outputs.MLServicesClusterRolesEdgeNode':
        """
        A `edge_node` block as defined above.
        """
        return pulumi.get(self, "edge_node")

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.MLServicesClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.MLServicesClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.MLServicesClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")


@pulumi.output_type
class MLServicesClusterRolesEdgeNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Edge Node. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Edge Node. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Edge Node. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Edge Node. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class MLServicesClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class MLServicesClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class MLServicesClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class MLServicesClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight ML Services Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight ML Services Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class RServerClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class RServerClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "edgeNode":
            suggest = "edge_node"
        elif key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"

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

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

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

    def __init__(__self__, *,
                 edge_node: 'outputs.RServerClusterRolesEdgeNode',
                 head_node: 'outputs.RServerClusterRolesHeadNode',
                 worker_node: 'outputs.RServerClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.RServerClusterRolesZookeeperNode'):
        """
        :param 'RServerClusterRolesEdgeNodeArgs' edge_node: A `edge_node` block as defined above.
        :param 'RServerClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'RServerClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'RServerClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        """
        pulumi.set(__self__, "edge_node", edge_node)
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)

    @property
    @pulumi.getter(name="edgeNode")
    def edge_node(self) -> 'outputs.RServerClusterRolesEdgeNode':
        """
        A `edge_node` block as defined above.
        """
        return pulumi.get(self, "edge_node")

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.RServerClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.RServerClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.RServerClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")


@pulumi.output_type
class RServerClusterRolesEdgeNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Edge Node. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Edge Node. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Edge Node. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Edge Node. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Edge Node. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Edge Node should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class RServerClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class RServerClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class RServerClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class RServerClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight RServer Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight RServer Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class SparkClusterComponentVersion(dict):
    def __init__(__self__, *,
                 spark: str):
        """
        :param str spark: The version of Spark which should be used for this HDInsight Spark Cluster. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "spark", spark)

    @property
    @pulumi.getter
    def spark(self) -> str:
        """
        The version of Spark which should be used for this HDInsight Spark Cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "spark")


@pulumi.output_type
class SparkClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class SparkClusterMetastores(dict):
    def __init__(__self__, *,
                 ambari: Optional['outputs.SparkClusterMetastoresAmbari'] = None,
                 hive: Optional['outputs.SparkClusterMetastoresHive'] = None,
                 oozie: Optional['outputs.SparkClusterMetastoresOozie'] = None):
        """
        :param 'SparkClusterMetastoresAmbariArgs' ambari: An `ambari` block as defined below.
        :param 'SparkClusterMetastoresHiveArgs' hive: A `hive` block as defined below.
        :param 'SparkClusterMetastoresOozieArgs' oozie: An `oozie` block as defined below.
        """
        if ambari is not None:
            pulumi.set(__self__, "ambari", ambari)
        if hive is not None:
            pulumi.set(__self__, "hive", hive)
        if oozie is not None:
            pulumi.set(__self__, "oozie", oozie)

    @property
    @pulumi.getter
    def ambari(self) -> Optional['outputs.SparkClusterMetastoresAmbari']:
        """
        An `ambari` block as defined below.
        """
        return pulumi.get(self, "ambari")

    @property
    @pulumi.getter
    def hive(self) -> Optional['outputs.SparkClusterMetastoresHive']:
        """
        A `hive` block as defined below.
        """
        return pulumi.get(self, "hive")

    @property
    @pulumi.getter
    def oozie(self) -> Optional['outputs.SparkClusterMetastoresOozie']:
        """
        An `oozie` block as defined below.
        """
        return pulumi.get(self, "oozie")


@pulumi.output_type
class SparkClusterMetastoresAmbari(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        :param str username: The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SparkClusterMetastoresHive(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        :param str username: The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SparkClusterMetastoresOozie(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        :param str username: The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SparkClusterMonitor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "primaryKey":
            suggest = "primary_key"

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

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

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

    def __init__(__self__, *,
                 log_analytics_workspace_id: str,
                 primary_key: str):
        """
        :param str log_analytics_workspace_id: The Operations Management Suite (OMS) workspace ID.
        :param str primary_key: The Operations Management Suite (OMS) workspace key.
        """
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "primary_key", primary_key)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The Operations Management Suite (OMS) workspace ID.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> str:
        """
        The Operations Management Suite (OMS) workspace key.
        """
        return pulumi.get(self, "primary_key")


@pulumi.output_type
class SparkClusterNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionDirection":
            suggest = "connection_direction"
        elif key == "privateLinkEnabled":
            suggest = "private_link_enabled"

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

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

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

    def __init__(__self__, *,
                 connection_direction: Optional[str] = None,
                 private_link_enabled: Optional[bool] = None):
        """
        :param str connection_direction: The direction of the resource provider connection. Possible values include `Inbound` or `Outbound`. Defaults to `Inbound`. Changing this forces a new resource to be created.
        :param bool private_link_enabled: Is the private link enabled? Possible values include `True` or `False`. Defaults to `False`. Changing this forces a new resource to be created.
        """
        if connection_direction is not None:
            pulumi.set(__self__, "connection_direction", connection_direction)
        if private_link_enabled is not None:
            pulumi.set(__self__, "private_link_enabled", private_link_enabled)

    @property
    @pulumi.getter(name="connectionDirection")
    def connection_direction(self) -> Optional[str]:
        """
        The direction of the resource provider connection. Possible values include `Inbound` or `Outbound`. Defaults to `Inbound`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "connection_direction")

    @property
    @pulumi.getter(name="privateLinkEnabled")
    def private_link_enabled(self) -> Optional[bool]:
        """
        Is the private link enabled? Possible values include `True` or `False`. Defaults to `False`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "private_link_enabled")


@pulumi.output_type
class SparkClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"

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

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

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

    def __init__(__self__, *,
                 head_node: 'outputs.SparkClusterRolesHeadNode',
                 worker_node: 'outputs.SparkClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.SparkClusterRolesZookeeperNode'):
        """
        :param 'SparkClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'SparkClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'SparkClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        """
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.SparkClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.SparkClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.SparkClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")


@pulumi.output_type
class SparkClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class SparkClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 autoscale: Optional['outputs.SparkClusterRolesWorkerNodeAutoscale'] = None,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param 'SparkClusterRolesWorkerNodeAutoscaleArgs' autoscale: A `autoscale` block as defined below.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if autoscale is not None:
            pulumi.set(__self__, "autoscale", autoscale)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def autoscale(self) -> Optional['outputs.SparkClusterRolesWorkerNodeAutoscale']:
        """
        A `autoscale` block as defined below.
        """
        return pulumi.get(self, "autoscale")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class SparkClusterRolesWorkerNodeAutoscale(dict):
    def __init__(__self__, *,
                 capacity: Optional['outputs.SparkClusterRolesWorkerNodeAutoscaleCapacity'] = None,
                 recurrence: Optional['outputs.SparkClusterRolesWorkerNodeAutoscaleRecurrence'] = None):
        """
        :param 'SparkClusterRolesWorkerNodeAutoscaleCapacityArgs' capacity: A `capacity` block as defined below.
        :param 'SparkClusterRolesWorkerNodeAutoscaleRecurrenceArgs' recurrence: A `recurrence` block as defined below.
        """
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)

    @property
    @pulumi.getter
    def capacity(self) -> Optional['outputs.SparkClusterRolesWorkerNodeAutoscaleCapacity']:
        """
        A `capacity` block as defined below.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def recurrence(self) -> Optional['outputs.SparkClusterRolesWorkerNodeAutoscaleRecurrence']:
        """
        A `recurrence` block as defined below.
        """
        return pulumi.get(self, "recurrence")


@pulumi.output_type
class SparkClusterRolesWorkerNodeAutoscaleCapacity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxInstanceCount":
            suggest = "max_instance_count"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"

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

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

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

    def __init__(__self__, *,
                 max_instance_count: int,
                 min_instance_count: int):
        """
        :param int max_instance_count: The maximum number of worker nodes to autoscale to based on the cluster's activity.
        :param int min_instance_count: The minimum number of worker nodes to autoscale to based on the cluster's activity.
        """
        pulumi.set(__self__, "max_instance_count", max_instance_count)
        pulumi.set(__self__, "min_instance_count", min_instance_count)

    @property
    @pulumi.getter(name="maxInstanceCount")
    def max_instance_count(self) -> int:
        """
        The maximum number of worker nodes to autoscale to based on the cluster's activity.
        """
        return pulumi.get(self, "max_instance_count")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> int:
        """
        The minimum number of worker nodes to autoscale to based on the cluster's activity.
        """
        return pulumi.get(self, "min_instance_count")


@pulumi.output_type
class SparkClusterRolesWorkerNodeAutoscaleRecurrence(dict):
    def __init__(__self__, *,
                 schedules: Sequence['outputs.SparkClusterRolesWorkerNodeAutoscaleRecurrenceSchedule'],
                 timezone: str):
        """
        :param Sequence['SparkClusterRolesWorkerNodeAutoscaleRecurrenceScheduleArgs'] schedules: A list of `schedule` blocks as defined below.
        :param str timezone: The time zone for the autoscale schedule times.
        """
        pulumi.set(__self__, "schedules", schedules)
        pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter
    def schedules(self) -> Sequence['outputs.SparkClusterRolesWorkerNodeAutoscaleRecurrenceSchedule']:
        """
        A list of `schedule` blocks as defined below.
        """
        return pulumi.get(self, "schedules")

    @property
    @pulumi.getter
    def timezone(self) -> str:
        """
        The time zone for the autoscale schedule times.
        """
        return pulumi.get(self, "timezone")


@pulumi.output_type
class SparkClusterRolesWorkerNodeAutoscaleRecurrenceSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"

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

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

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

    def __init__(__self__, *,
                 days: Sequence[str],
                 target_instance_count: int,
                 time: str):
        """
        :param Sequence[str] days: The days of the week to perform autoscale.
        :param int target_instance_count: The number of worker nodes to autoscale at the specified time.
        :param str time: The time of day to perform the autoscale in 24hour format.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "time", time)

    @property
    @pulumi.getter
    def days(self) -> Sequence[str]:
        """
        The days of the week to perform autoscale.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of worker nodes to autoscale at the specified time.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def time(self) -> str:
        """
        The time of day to perform the autoscale in 24hour format.
        """
        return pulumi.get(self, "time")


@pulumi.output_type
class SparkClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class SparkClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class SparkClusterStorageAccountGen2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filesystemId":
            suggest = "filesystem_id"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "managedIdentityResourceId":
            suggest = "managed_identity_resource_id"
        elif key == "storageResourceId":
            suggest = "storage_resource_id"

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

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

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

    def __init__(__self__, *,
                 filesystem_id: str,
                 is_default: bool,
                 managed_identity_resource_id: str,
                 storage_resource_id: str):
        """
        :param str filesystem_id: The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        :param bool is_default: Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        :param str managed_identity_resource_id: The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        :param str storage_resource_id: The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "filesystem_id", filesystem_id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "managed_identity_resource_id", managed_identity_resource_id)
        pulumi.set(__self__, "storage_resource_id", storage_resource_id)

    @property
    @pulumi.getter(name="filesystemId")
    def filesystem_id(self) -> str:
        """
        The ID of the Gen2 Filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "filesystem_id")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Hadoop Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="managedIdentityResourceId")
    def managed_identity_resource_id(self) -> str:
        """
        The ID of Managed Identity to use for accessing the Gen2 filesystem. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "managed_identity_resource_id")

    @property
    @pulumi.getter(name="storageResourceId")
    def storage_resource_id(self) -> str:
        """
        The ID of the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_resource_id")


@pulumi.output_type
class StormClusterComponentVersion(dict):
    def __init__(__self__, *,
                 storm: str):
        """
        :param str storm: The version of Storm which should be used for this HDInsight Storm Cluster. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "storm", storm)

    @property
    @pulumi.getter
    def storm(self) -> str:
        """
        The version of Storm which should be used for this HDInsight Storm Cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storm")


@pulumi.output_type
class StormClusterGateway(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str,
                 enabled: Optional[bool] = None):
        """
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal. Changing this forces a new resource to be created.
        :param bool enabled: Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is the Ambari portal enabled? The HDInsight API doesn't support disabling gateway anymore.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class StormClusterMetastores(dict):
    def __init__(__self__, *,
                 ambari: Optional['outputs.StormClusterMetastoresAmbari'] = None,
                 hive: Optional['outputs.StormClusterMetastoresHive'] = None,
                 oozie: Optional['outputs.StormClusterMetastoresOozie'] = None):
        """
        :param 'StormClusterMetastoresAmbariArgs' ambari: An `ambari` block as defined below.
        :param 'StormClusterMetastoresHiveArgs' hive: A `hive` block as defined below.
        :param 'StormClusterMetastoresOozieArgs' oozie: An `oozie` block as defined below.
        """
        if ambari is not None:
            pulumi.set(__self__, "ambari", ambari)
        if hive is not None:
            pulumi.set(__self__, "hive", hive)
        if oozie is not None:
            pulumi.set(__self__, "oozie", oozie)

    @property
    @pulumi.getter
    def ambari(self) -> Optional['outputs.StormClusterMetastoresAmbari']:
        """
        An `ambari` block as defined below.
        """
        return pulumi.get(self, "ambari")

    @property
    @pulumi.getter
    def hive(self) -> Optional['outputs.StormClusterMetastoresHive']:
        """
        A `hive` block as defined below.
        """
        return pulumi.get(self, "hive")

    @property
    @pulumi.getter
    def oozie(self) -> Optional['outputs.StormClusterMetastoresOozie']:
        """
        An `oozie` block as defined below.
        """
        return pulumi.get(self, "oozie")


@pulumi.output_type
class StormClusterMetastoresAmbari(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        :param str username: The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Ambari metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Ambari metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class StormClusterMetastoresHive(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        :param str username: The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Hive metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Hive metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Hive metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Hive metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class StormClusterMetastoresOozie(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str database_name: The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        :param str password: The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        :param str server: The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        :param str username: The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The external Oozie metastore's existing SQL database.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin password.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The fully-qualified domain name (FQDN) of the SQL server to use for the external Oozie metastore.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The external Oozie metastore's existing SQL server admin username.  Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class StormClusterMonitor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "primaryKey":
            suggest = "primary_key"

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

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

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

    def __init__(__self__, *,
                 log_analytics_workspace_id: str,
                 primary_key: str):
        """
        :param str log_analytics_workspace_id: The Operations Management Suite (OMS) workspace ID.
        :param str primary_key: The Operations Management Suite (OMS) workspace key.
        """
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "primary_key", primary_key)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The Operations Management Suite (OMS) workspace ID.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> str:
        """
        The Operations Management Suite (OMS) workspace key.
        """
        return pulumi.get(self, "primary_key")


@pulumi.output_type
class StormClusterRoles(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headNode":
            suggest = "head_node"
        elif key == "workerNode":
            suggest = "worker_node"
        elif key == "zookeeperNode":
            suggest = "zookeeper_node"

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

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

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

    def __init__(__self__, *,
                 head_node: 'outputs.StormClusterRolesHeadNode',
                 worker_node: 'outputs.StormClusterRolesWorkerNode',
                 zookeeper_node: 'outputs.StormClusterRolesZookeeperNode'):
        """
        :param 'StormClusterRolesHeadNodeArgs' head_node: A `head_node` block as defined above.
        :param 'StormClusterRolesWorkerNodeArgs' worker_node: A `worker_node` block as defined below.
        :param 'StormClusterRolesZookeeperNodeArgs' zookeeper_node: A `zookeeper_node` block as defined below.
        """
        pulumi.set(__self__, "head_node", head_node)
        pulumi.set(__self__, "worker_node", worker_node)
        pulumi.set(__self__, "zookeeper_node", zookeeper_node)

    @property
    @pulumi.getter(name="headNode")
    def head_node(self) -> 'outputs.StormClusterRolesHeadNode':
        """
        A `head_node` block as defined above.
        """
        return pulumi.get(self, "head_node")

    @property
    @pulumi.getter(name="workerNode")
    def worker_node(self) -> 'outputs.StormClusterRolesWorkerNode':
        """
        A `worker_node` block as defined below.
        """
        return pulumi.get(self, "worker_node")

    @property
    @pulumi.getter(name="zookeeperNode")
    def zookeeper_node(self) -> 'outputs.StormClusterRolesZookeeperNode':
        """
        A `zookeeper_node` block as defined below.
        """
        return pulumi.get(self, "zookeeper_node")


@pulumi.output_type
class StormClusterRolesHeadNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Head Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Head Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class StormClusterRolesWorkerNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetInstanceCount":
            suggest = "target_instance_count"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "minInstanceCount":
            suggest = "min_instance_count"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 target_instance_count: int,
                 username: str,
                 vm_size: str,
                 min_instance_count: Optional[int] = None,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param int target_instance_count: The number of instances which should be run for the Worker Nodes.
        :param str username: The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        :param int min_instance_count: The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "target_instance_count", target_instance_count)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if min_instance_count is not None:
            pulumi.set(__self__, "min_instance_count", min_instance_count)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="targetInstanceCount")
    def target_instance_count(self) -> int:
        """
        The number of instances which should be run for the Worker Nodes.
        """
        return pulumi.get(self, "target_instance_count")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="minInstanceCount")
    def min_instance_count(self) -> Optional[int]:
        """
        The minimum number of instances which should be run for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "min_instance_count")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Worker Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Worker Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class StormClusterRolesZookeeperNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "sshKeys":
            suggest = "ssh_keys"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "virtualNetworkId":
            suggest = "virtual_network_id"

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

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

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

    def __init__(__self__, *,
                 username: str,
                 vm_size: str,
                 password: Optional[str] = None,
                 ssh_keys: Optional[Sequence[str]] = None,
                 subnet_id: Optional[str] = None,
                 virtual_network_id: Optional[str] = None):
        """
        :param str username: The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str vm_size: The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str password: The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param Sequence[str] ssh_keys: A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        :param str subnet_id: The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        :param str virtual_network_id: The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vm_size", vm_size)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_keys is not None:
            pulumi.set(__self__, "ssh_keys", ssh_keys)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if virtual_network_id is not None:
            pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The Username of the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The Size of the Virtual Machine which should be used as the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The Password associated with the local administrator for the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Optional[Sequence[str]]:
        """
        A list of SSH Keys which should be used for the local administrator on the Zookeeper Nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_keys")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet within the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> Optional[str]:
        """
        The ID of the Virtual Network where the Zookeeper Nodes should be provisioned within. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class StormClusterStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isDefault":
            suggest = "is_default"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageContainerId":
            suggest = "storage_container_id"

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

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

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

    def __init__(__self__, *,
                 is_default: bool,
                 storage_account_key: str,
                 storage_container_id: str):
        """
        :param bool is_default: Is this the Default Storage Account for the HDInsight Storm Cluster? Changing this forces a new resource to be created.
        :param str storage_account_key: The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        :param str storage_container_id: The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "storage_account_key", storage_account_key)
        pulumi.set(__self__, "storage_container_id", storage_container_id)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Is this the Default Storage Account for the HDInsight Storm Cluster? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> str:
        """
        The Access Key which should be used to connect to the Storage Account. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageContainerId")
    def storage_container_id(self) -> str:
        """
        The ID of the Storage Container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_container_id")


@pulumi.output_type
class GetClusterGatewayResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 password: str,
                 username: str):
        """
        :param bool enabled: Is the Ambari Portal enabled?
        :param str password: The password used for the Ambari Portal.
        :param str username: The username used for the Ambari Portal.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the Ambari Portal enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used for the Ambari Portal.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used for the Ambari Portal.
        """
        return pulumi.get(self, "username")


