# pylint: disable=line-too-long,useless-suppression,too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) Python Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
# pylint: disable=useless-super-delegation

import datetime
from typing import Any, Mapping, Optional, TYPE_CHECKING, Union, overload

from .._utils.model_base import Model as _Model, rest_field

if TYPE_CHECKING:
    from .. import models as _models


class AaddsResourceDetails(_Model):
    """The Azure active directory domain service resource details.

    :ivar domain_name: The Azure active directory domain service name.
    :vartype domain_name: str
    :ivar initial_sync_complete: This indicates whether initial sync complete or not.
    :vartype initial_sync_complete: bool
    :ivar ldaps_enabled: This indicates whether enable ldaps or not.
    :vartype ldaps_enabled: bool
    :ivar ldaps_public_certificate_in_base64: The base 64 format string of public ldap certificate.
    :vartype ldaps_public_certificate_in_base64: str
    :ivar resource_id: The resource id of azure active directory domain service.
    :vartype resource_id: str
    :ivar subnet_id: The subnet resource id.
    :vartype subnet_id: str
    :ivar tenant_id: The tenant id of azure active directory domain service .
    :vartype tenant_id: str
    """

    domain_name: Optional[str] = rest_field(
        name="domainName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The Azure active directory domain service name."""
    initial_sync_complete: Optional[bool] = rest_field(
        name="initialSyncComplete", visibility=["read", "create", "update", "delete", "query"]
    )
    """This indicates whether initial sync complete or not."""
    ldaps_enabled: Optional[bool] = rest_field(
        name="ldapsEnabled", visibility=["read", "create", "update", "delete", "query"]
    )
    """This indicates whether enable ldaps or not."""
    ldaps_public_certificate_in_base64: Optional[str] = rest_field(
        name="ldapsPublicCertificateInBase64", visibility=["read", "create", "update", "delete", "query"]
    )
    """The base 64 format string of public ldap certificate."""
    resource_id: Optional[str] = rest_field(
        name="resourceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The resource id of azure active directory domain service."""
    subnet_id: Optional[str] = rest_field(name="subnetId", visibility=["read", "create", "update", "delete", "query"])
    """The subnet resource id."""
    tenant_id: Optional[str] = rest_field(name="tenantId", visibility=["read", "create", "update", "delete", "query"])
    """The tenant id of azure active directory domain service ."""

    @overload
    def __init__(
        self,
        *,
        domain_name: Optional[str] = None,
        initial_sync_complete: Optional[bool] = None,
        ldaps_enabled: Optional[bool] = None,
        ldaps_public_certificate_in_base64: Optional[str] = None,
        resource_id: Optional[str] = None,
        subnet_id: Optional[str] = None,
        tenant_id: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Resource(_Model):
    """Resource.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    """

    id: Optional[str] = rest_field(visibility=["read"])
    """Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}."""
    name: Optional[str] = rest_field(visibility=["read"])
    """The name of the resource."""
    type: Optional[str] = rest_field(visibility=["read"])
    """The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or
     \"Microsoft.Storage/storageAccounts\"."""
    system_data: Optional["_models.SystemData"] = rest_field(name="systemData", visibility=["read"])
    """Azure Resource Manager metadata containing createdBy and modifiedBy information."""


class ProxyResource(Resource):
    """Proxy Resource.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    """


class Application(ProxyResource):
    """The HDInsight cluster application.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    :ivar properties: The properties of the application.
    :vartype properties: ~azure.mgmt.hdinsight.models.ApplicationProperties
    :ivar etag: The ETag for the application.
    :vartype etag: str
    :ivar tags: The tags for the application.
    :vartype tags: dict[str, str]
    """

    properties: Optional["_models.ApplicationProperties"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The properties of the application."""
    etag: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The ETag for the application."""
    tags: Optional[dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The tags for the application."""

    @overload
    def __init__(
        self,
        *,
        properties: Optional["_models.ApplicationProperties"] = None,
        etag: Optional[str] = None,
        tags: Optional[dict[str, str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ApplicationGetEndpoint(_Model):
    """Gets the application SSH endpoint.

    :ivar location: The location of the endpoint.
    :vartype location: str
    :ivar destination_port: The destination port to connect to.
    :vartype destination_port: int
    :ivar public_port: The public port to connect to.
    :vartype public_port: int
    :ivar private_ip_address: The private ip address of the endpoint.
    :vartype private_ip_address: str
    """

    location: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The location of the endpoint."""
    destination_port: Optional[int] = rest_field(
        name="destinationPort", visibility=["read", "create", "update", "delete", "query"]
    )
    """The destination port to connect to."""
    public_port: Optional[int] = rest_field(
        name="publicPort", visibility=["read", "create", "update", "delete", "query"]
    )
    """The public port to connect to."""
    private_ip_address: Optional[str] = rest_field(name="privateIPAddress", visibility=["read", "create"])
    """The private ip address of the endpoint."""

    @overload
    def __init__(
        self,
        *,
        location: Optional[str] = None,
        destination_port: Optional[int] = None,
        public_port: Optional[int] = None,
        private_ip_address: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ApplicationGetHttpsEndpoint(_Model):
    """Gets the application HTTP endpoints.

    :ivar access_modes: The list of access modes for the application.
    :vartype access_modes: list[str]
    :ivar location: The location of the endpoint.
    :vartype location: str
    :ivar destination_port: The destination port to connect to.
    :vartype destination_port: int
    :ivar public_port: The public port to connect to.
    :vartype public_port: int
    :ivar private_ip_address: The private ip address of the endpoint.
    :vartype private_ip_address: str
    :ivar sub_domain_suffix: The subdomain suffix of the application.
    :vartype sub_domain_suffix: str
    :ivar disable_gateway_auth: The value indicates whether to disable GatewayAuth.
    :vartype disable_gateway_auth: bool
    """

    access_modes: Optional[list[str]] = rest_field(
        name="accessModes", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of access modes for the application."""
    location: Optional[str] = rest_field(visibility=["read"])
    """The location of the endpoint."""
    destination_port: Optional[int] = rest_field(
        name="destinationPort", visibility=["read", "create", "update", "delete", "query"]
    )
    """The destination port to connect to."""
    public_port: Optional[int] = rest_field(name="publicPort", visibility=["read"])
    """The public port to connect to."""
    private_ip_address: Optional[str] = rest_field(name="privateIPAddress", visibility=["read", "create"])
    """The private ip address of the endpoint."""
    sub_domain_suffix: Optional[str] = rest_field(name="subDomainSuffix", visibility=["create", "update"])
    """The subdomain suffix of the application."""
    disable_gateway_auth: Optional[bool] = rest_field(
        name="disableGatewayAuth", visibility=["read", "create", "update", "delete", "query"]
    )
    """The value indicates whether to disable GatewayAuth."""

    @overload
    def __init__(
        self,
        *,
        access_modes: Optional[list[str]] = None,
        destination_port: Optional[int] = None,
        private_ip_address: Optional[str] = None,
        sub_domain_suffix: Optional[str] = None,
        disable_gateway_auth: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ApplicationProperties(_Model):
    """The HDInsight cluster application GET response.

    :ivar compute_profile: The list of roles in the cluster.
    :vartype compute_profile: ~azure.mgmt.hdinsight.models.ComputeProfile
    :ivar install_script_actions: The list of install script actions.
    :vartype install_script_actions: list[~azure.mgmt.hdinsight.models.RuntimeScriptAction]
    :ivar uninstall_script_actions: The list of uninstall script actions.
    :vartype uninstall_script_actions: list[~azure.mgmt.hdinsight.models.RuntimeScriptAction]
    :ivar https_endpoints: The list of application HTTPS endpoints.
    :vartype https_endpoints: list[~azure.mgmt.hdinsight.models.ApplicationGetHttpsEndpoint]
    :ivar ssh_endpoints: The list of application SSH endpoints.
    :vartype ssh_endpoints: list[~azure.mgmt.hdinsight.models.ApplicationGetEndpoint]
    :ivar provisioning_state: The provisioning state of the application.
    :vartype provisioning_state: str
    :ivar application_type: The application type.
    :vartype application_type: str
    :ivar application_state: The application state.
    :vartype application_state: str
    :ivar errors: The list of errors.
    :vartype errors: list[~azure.mgmt.hdinsight.models.Errors]
    :ivar created_date: The application create date time.
    :vartype created_date: str
    :ivar marketplace_identifier: The marketplace identifier.
    :vartype marketplace_identifier: str
    :ivar private_link_configurations: The private link configurations.
    :vartype private_link_configurations:
     list[~azure.mgmt.hdinsight.models.PrivateLinkConfiguration]
    """

    compute_profile: Optional["_models.ComputeProfile"] = rest_field(
        name="computeProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of roles in the cluster."""
    install_script_actions: Optional[list["_models.RuntimeScriptAction"]] = rest_field(
        name="installScriptActions", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of install script actions."""
    uninstall_script_actions: Optional[list["_models.RuntimeScriptAction"]] = rest_field(
        name="uninstallScriptActions", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of uninstall script actions."""
    https_endpoints: Optional[list["_models.ApplicationGetHttpsEndpoint"]] = rest_field(
        name="httpsEndpoints", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of application HTTPS endpoints."""
    ssh_endpoints: Optional[list["_models.ApplicationGetEndpoint"]] = rest_field(
        name="sshEndpoints", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of application SSH endpoints."""
    provisioning_state: Optional[str] = rest_field(name="provisioningState", visibility=["read"])
    """The provisioning state of the application."""
    application_type: Optional[str] = rest_field(
        name="applicationType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The application type."""
    application_state: Optional[str] = rest_field(name="applicationState", visibility=["read"])
    """The application state."""
    errors: Optional[list["_models.Errors"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The list of errors."""
    created_date: Optional[str] = rest_field(name="createdDate", visibility=["read"])
    """The application create date time."""
    marketplace_identifier: Optional[str] = rest_field(name="marketplaceIdentifier", visibility=["read"])
    """The marketplace identifier."""
    private_link_configurations: Optional[list["_models.PrivateLinkConfiguration"]] = rest_field(
        name="privateLinkConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link configurations."""

    @overload
    def __init__(
        self,
        *,
        compute_profile: Optional["_models.ComputeProfile"] = None,
        install_script_actions: Optional[list["_models.RuntimeScriptAction"]] = None,
        uninstall_script_actions: Optional[list["_models.RuntimeScriptAction"]] = None,
        https_endpoints: Optional[list["_models.ApplicationGetHttpsEndpoint"]] = None,
        ssh_endpoints: Optional[list["_models.ApplicationGetEndpoint"]] = None,
        application_type: Optional[str] = None,
        errors: Optional[list["_models.Errors"]] = None,
        private_link_configurations: Optional[list["_models.PrivateLinkConfiguration"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AsyncOperationResult(_Model):
    """The azure async operation response.

    :ivar status: The async operation state. Known values are: "InProgress", "Succeeded", and
     "Failed".
    :vartype status: str or ~azure.mgmt.hdinsight.models.AsyncOperationState
    :ivar error: The operation error information.
    :vartype error: ~azure.mgmt.hdinsight.models.Errors
    """

    status: Optional[Union[str, "_models.AsyncOperationState"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The async operation state. Known values are: \"InProgress\", \"Succeeded\", and \"Failed\"."""
    error: Optional["_models.Errors"] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The operation error information."""

    @overload
    def __init__(
        self,
        *,
        status: Optional[Union[str, "_models.AsyncOperationState"]] = None,
        error: Optional["_models.Errors"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Autoscale(_Model):
    """The autoscale request parameters.

    :ivar capacity: Parameters for load-based autoscale.
    :vartype capacity: ~azure.mgmt.hdinsight.models.AutoscaleCapacity
    :ivar recurrence: Parameters for schedule-based autoscale.
    :vartype recurrence: ~azure.mgmt.hdinsight.models.AutoscaleRecurrence
    """

    capacity: Optional["_models.AutoscaleCapacity"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """Parameters for load-based autoscale."""
    recurrence: Optional["_models.AutoscaleRecurrence"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """Parameters for schedule-based autoscale."""

    @overload
    def __init__(
        self,
        *,
        capacity: Optional["_models.AutoscaleCapacity"] = None,
        recurrence: Optional["_models.AutoscaleRecurrence"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AutoscaleCapacity(_Model):
    """The load-based autoscale request parameters.

    :ivar min_instance_count: The minimum instance count of the cluster.
    :vartype min_instance_count: int
    :ivar max_instance_count: The maximum instance count of the cluster.
    :vartype max_instance_count: int
    """

    min_instance_count: Optional[int] = rest_field(
        name="minInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The minimum instance count of the cluster."""
    max_instance_count: Optional[int] = rest_field(
        name="maxInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The maximum instance count of the cluster."""

    @overload
    def __init__(
        self,
        *,
        min_instance_count: Optional[int] = None,
        max_instance_count: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AutoscaleConfigurationUpdateParameter(_Model):
    """The autoscale configuration update parameter.

    :ivar autoscale: The autoscale configuration.
    :vartype autoscale: ~azure.mgmt.hdinsight.models.Autoscale
    """

    autoscale: Optional["_models.Autoscale"] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The autoscale configuration."""

    @overload
    def __init__(
        self,
        *,
        autoscale: Optional["_models.Autoscale"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AutoscaleRecurrence(_Model):
    """Schedule-based autoscale request parameters.

    :ivar time_zone: The time zone for the autoscale schedule times.
    :vartype time_zone: str
    :ivar schedule: Array of schedule-based autoscale rules.
    :vartype schedule: list[~azure.mgmt.hdinsight.models.AutoscaleSchedule]
    """

    time_zone: Optional[str] = rest_field(name="timeZone", visibility=["read", "create", "update", "delete", "query"])
    """The time zone for the autoscale schedule times."""
    schedule: Optional[list["_models.AutoscaleSchedule"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """Array of schedule-based autoscale rules."""

    @overload
    def __init__(
        self,
        *,
        time_zone: Optional[str] = None,
        schedule: Optional[list["_models.AutoscaleSchedule"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AutoscaleSchedule(_Model):
    """Parameters for a schedule-based autoscale rule, consisting of an array of days + a time and
    capacity.

    :ivar days: Days of the week for a schedule-based autoscale rule.
    :vartype days: list[str or ~azure.mgmt.hdinsight.models.DaysOfWeek]
    :ivar time_and_capacity: Time and capacity for a schedule-based autoscale rule.
    :vartype time_and_capacity: ~azure.mgmt.hdinsight.models.AutoscaleTimeAndCapacity
    """

    days: Optional[list[Union[str, "_models.DaysOfWeek"]]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """Days of the week for a schedule-based autoscale rule."""
    time_and_capacity: Optional["_models.AutoscaleTimeAndCapacity"] = rest_field(
        name="timeAndCapacity", visibility=["read", "create", "update", "delete", "query"]
    )
    """Time and capacity for a schedule-based autoscale rule."""

    @overload
    def __init__(
        self,
        *,
        days: Optional[list[Union[str, "_models.DaysOfWeek"]]] = None,
        time_and_capacity: Optional["_models.AutoscaleTimeAndCapacity"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AutoscaleTimeAndCapacity(_Model):
    """Time and capacity request parameters.

    :ivar time: 24-hour time in the form xx:xx.
    :vartype time: str
    :ivar min_instance_count: The minimum instance count of the cluster.
    :vartype min_instance_count: int
    :ivar max_instance_count: The maximum instance count of the cluster.
    :vartype max_instance_count: int
    """

    time: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """24-hour time in the form xx:xx."""
    min_instance_count: Optional[int] = rest_field(
        name="minInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The minimum instance count of the cluster."""
    max_instance_count: Optional[int] = rest_field(
        name="maxInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The maximum instance count of the cluster."""

    @overload
    def __init__(
        self,
        *,
        time: Optional[str] = None,
        min_instance_count: Optional[int] = None,
        max_instance_count: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AzureMonitorRequest(_Model):
    """The azure monitor parameters.

    :ivar workspace_id: The Log Analytics workspace ID.
    :vartype workspace_id: str
    :ivar primary_key: The Log Analytics workspace key.
    :vartype primary_key: str
    :ivar selected_configurations: The selected configurations.
    :vartype selected_configurations:
     ~azure.mgmt.hdinsight.models.AzureMonitorSelectedConfigurations
    """

    workspace_id: Optional[str] = rest_field(
        name="workspaceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The Log Analytics workspace ID."""
    primary_key: Optional[str] = rest_field(
        name="primaryKey", visibility=["read", "create", "update", "delete", "query"]
    )
    """The Log Analytics workspace key."""
    selected_configurations: Optional["_models.AzureMonitorSelectedConfigurations"] = rest_field(
        name="selectedConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The selected configurations."""

    @overload
    def __init__(
        self,
        *,
        workspace_id: Optional[str] = None,
        primary_key: Optional[str] = None,
        selected_configurations: Optional["_models.AzureMonitorSelectedConfigurations"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AzureMonitorResponse(_Model):
    """The azure monitor status response.

    :ivar cluster_monitoring_enabled: The status of the monitor on the HDInsight cluster.
    :vartype cluster_monitoring_enabled: bool
    :ivar workspace_id: The workspace ID of the monitor on the HDInsight cluster.
    :vartype workspace_id: str
    :ivar selected_configurations: The selected configurations.
    :vartype selected_configurations:
     ~azure.mgmt.hdinsight.models.AzureMonitorSelectedConfigurations
    """

    cluster_monitoring_enabled: Optional[bool] = rest_field(
        name="clusterMonitoringEnabled", visibility=["read", "create", "update", "delete", "query"]
    )
    """The status of the monitor on the HDInsight cluster."""
    workspace_id: Optional[str] = rest_field(
        name="workspaceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The workspace ID of the monitor on the HDInsight cluster."""
    selected_configurations: Optional["_models.AzureMonitorSelectedConfigurations"] = rest_field(
        name="selectedConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The selected configurations."""

    @overload
    def __init__(
        self,
        *,
        cluster_monitoring_enabled: Optional[bool] = None,
        workspace_id: Optional[str] = None,
        selected_configurations: Optional["_models.AzureMonitorSelectedConfigurations"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AzureMonitorSelectedConfigurations(_Model):
    """The selected configurations for azure monitor.

    :ivar configuration_version: The configuration version.
    :vartype configuration_version: str
    :ivar global_configurations: The global configurations of selected configurations.
    :vartype global_configurations: dict[str, str]
    :ivar table_list: The table list.
    :vartype table_list: list[~azure.mgmt.hdinsight.models.AzureMonitorTableConfiguration]
    """

    configuration_version: Optional[str] = rest_field(
        name="configurationVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """The configuration version."""
    global_configurations: Optional[dict[str, str]] = rest_field(
        name="globalConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The global configurations of selected configurations."""
    table_list: Optional[list["_models.AzureMonitorTableConfiguration"]] = rest_field(
        name="tableList", visibility=["read", "create", "update", "delete", "query"]
    )
    """The table list."""

    @overload
    def __init__(
        self,
        *,
        configuration_version: Optional[str] = None,
        global_configurations: Optional[dict[str, str]] = None,
        table_list: Optional[list["_models.AzureMonitorTableConfiguration"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AzureMonitorTableConfiguration(_Model):
    """The table configuration for the Log Analytics integration.

    :ivar name: The name.
    :vartype name: str
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class BillingMeters(_Model):
    """The billing meters.

    :ivar meter_parameter: The virtual machine sizes.
    :vartype meter_parameter: str
    :ivar meter: The HDInsight meter guid.
    :vartype meter: str
    :ivar unit: The unit of meter, VMHours or CoreHours.
    :vartype unit: str
    """

    meter_parameter: Optional[str] = rest_field(
        name="meterParameter", visibility=["read", "create", "update", "delete", "query"]
    )
    """The virtual machine sizes."""
    meter: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The HDInsight meter guid."""
    unit: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The unit of meter, VMHours or CoreHours."""

    @overload
    def __init__(
        self,
        *,
        meter_parameter: Optional[str] = None,
        meter: Optional[str] = None,
        unit: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class BillingResources(_Model):
    """The billing resources.

    :ivar region: The region or location.
    :vartype region: str
    :ivar billing_meters: The billing meter information.
    :vartype billing_meters: list[~azure.mgmt.hdinsight.models.BillingMeters]
    :ivar disk_billing_meters: The managed disk billing information.
    :vartype disk_billing_meters: list[~azure.mgmt.hdinsight.models.DiskBillingMeters]
    """

    region: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The region or location."""
    billing_meters: Optional[list["_models.BillingMeters"]] = rest_field(
        name="billingMeters", visibility=["read", "create", "update", "delete", "query"]
    )
    """The billing meter information."""
    disk_billing_meters: Optional[list["_models.DiskBillingMeters"]] = rest_field(
        name="diskBillingMeters", visibility=["read", "create", "update", "delete", "query"]
    )
    """The managed disk billing information."""

    @overload
    def __init__(
        self,
        *,
        region: Optional[str] = None,
        billing_meters: Optional[list["_models.BillingMeters"]] = None,
        disk_billing_meters: Optional[list["_models.DiskBillingMeters"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class BillingResponseListResult(_Model):
    """The response for the operation to get regional billingSpecs for a subscription.

    :ivar vm_sizes: The virtual machine sizes to include or exclude.
    :vartype vm_sizes: list[str]
    :ivar vm_sizes_with_encryption_at_host: The vm sizes which enable encryption at host.
    :vartype vm_sizes_with_encryption_at_host: list[str]
    :ivar vm_size_filters: The virtual machine filtering mode. Effectively this can enabling or
     disabling the virtual machine sizes in a particular set.
    :vartype vm_size_filters: list[~azure.mgmt.hdinsight.models.VmSizeCompatibilityFilterV2]
    :ivar vm_size_properties: The vm size properties.
    :vartype vm_size_properties: list[~azure.mgmt.hdinsight.models.VmSizeProperty]
    :ivar billing_resources: The billing and managed disk billing resources for a region.
    :vartype billing_resources: list[~azure.mgmt.hdinsight.models.BillingResources]
    """

    vm_sizes: Optional[list[str]] = rest_field(
        name="vmSizes", visibility=["read", "create", "update", "delete", "query"]
    )
    """The virtual machine sizes to include or exclude."""
    vm_sizes_with_encryption_at_host: Optional[list[str]] = rest_field(
        name="vmSizesWithEncryptionAtHost", visibility=["read", "create", "update", "delete", "query"]
    )
    """The vm sizes which enable encryption at host."""
    vm_size_filters: Optional[list["_models.VmSizeCompatibilityFilterV2"]] = rest_field(
        name="vmSizeFilters", visibility=["read", "create", "update", "delete", "query"]
    )
    """The virtual machine filtering mode. Effectively this can enabling or disabling the virtual
     machine sizes in a particular set."""
    vm_size_properties: Optional[list["_models.VmSizeProperty"]] = rest_field(
        name="vmSizeProperties", visibility=["read"]
    )
    """The vm size properties."""
    billing_resources: Optional[list["_models.BillingResources"]] = rest_field(
        name="billingResources", visibility=["read", "create", "update", "delete", "query"]
    )
    """The billing and managed disk billing resources for a region."""

    @overload
    def __init__(
        self,
        *,
        vm_sizes: Optional[list[str]] = None,
        vm_sizes_with_encryption_at_host: Optional[list[str]] = None,
        vm_size_filters: Optional[list["_models.VmSizeCompatibilityFilterV2"]] = None,
        billing_resources: Optional[list["_models.BillingResources"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class CapabilitiesResult(_Model):
    """The Get Capabilities operation response.

    :ivar versions: The version capability.
    :vartype versions: dict[str, ~azure.mgmt.hdinsight.models.VersionsCapability]
    :ivar regions: The virtual machine size compatibility features.
    :vartype regions: dict[str, ~azure.mgmt.hdinsight.models.RegionsCapability]
    :ivar features: The capability features.
    :vartype features: list[str]
    :ivar quota: The quota capability.
    :vartype quota: ~azure.mgmt.hdinsight.models.QuotaCapability
    """

    versions: Optional[dict[str, "_models.VersionsCapability"]] = rest_field(visibility=["read"])
    """The version capability."""
    regions: Optional[dict[str, "_models.RegionsCapability"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The virtual machine size compatibility features."""
    features: Optional[list[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The capability features."""
    quota: Optional["_models.QuotaCapability"] = rest_field(visibility=["read"])
    """The quota capability."""

    @overload
    def __init__(
        self,
        *,
        regions: Optional[dict[str, "_models.RegionsCapability"]] = None,
        features: Optional[list[str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClientGroupInfo(_Model):
    """The information of AAD security group.

    :ivar group_name: The AAD security group name.
    :vartype group_name: str
    :ivar group_id: The AAD security group id.
    :vartype group_id: str
    """

    group_name: Optional[str] = rest_field(name="groupName", visibility=["read", "create", "update", "delete", "query"])
    """The AAD security group name."""
    group_id: Optional[str] = rest_field(name="groupId", visibility=["read", "create", "update", "delete", "query"])
    """The AAD security group id."""

    @overload
    def __init__(
        self,
        *,
        group_name: Optional[str] = None,
        group_id: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class TrackedResource(Resource):
    """Tracked Resource.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    :ivar tags: Resource tags.
    :vartype tags: dict[str, str]
    :ivar location: The geo-location where the resource lives. Required.
    :vartype location: str
    """

    tags: Optional[dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """Resource tags."""
    location: str = rest_field(visibility=["read", "create"])
    """The geo-location where the resource lives. Required."""

    @overload
    def __init__(
        self,
        *,
        location: str,
        tags: Optional[dict[str, str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Cluster(TrackedResource):
    """The HDInsight cluster.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    :ivar tags: Resource tags.
    :vartype tags: dict[str, str]
    :ivar location: The geo-location where the resource lives. Required.
    :vartype location: str
    :ivar properties: The properties of the cluster.
    :vartype properties: ~azure.mgmt.hdinsight.models.ClusterGetProperties
    :ivar etag: The ETag for the resource.
    :vartype etag: str
    :ivar zones: The availability zones.
    :vartype zones: list[str]
    :ivar identity: The identity of the cluster, if configured.
    :vartype identity: ~azure.mgmt.hdinsight.models.ClusterIdentity
    """

    properties: Optional["_models.ClusterGetProperties"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The properties of the cluster."""
    etag: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The ETag for the resource."""
    zones: Optional[list[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The availability zones."""
    identity: Optional["_models.ClusterIdentity"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The identity of the cluster, if configured."""

    @overload
    def __init__(
        self,
        *,
        location: str,
        tags: Optional[dict[str, str]] = None,
        properties: Optional["_models.ClusterGetProperties"] = None,
        etag: Optional[str] = None,
        zones: Optional[list[str]] = None,
        identity: Optional["_models.ClusterIdentity"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterConfigurations(_Model):
    """The configuration object for the specified cluster.

    :ivar configurations: The configuration object for the specified configuration for the
     specified cluster.
    :vartype configurations: dict[str, dict[str, str]]
    """

    configurations: Optional[dict[str, dict[str, str]]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The configuration object for the specified configuration for the specified cluster."""

    @overload
    def __init__(
        self,
        *,
        configurations: Optional[dict[str, dict[str, str]]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterCreateParametersExtended(_Model):
    """The CreateCluster request parameters.

    :ivar location: The location of the cluster.
    :vartype location: str
    :ivar tags: The resource tags.
    :vartype tags: dict[str, str]
    :ivar zones: The availability zones.
    :vartype zones: list[str]
    :ivar properties: The cluster create parameters.
    :vartype properties: ~azure.mgmt.hdinsight.models.ClusterCreateProperties
    :ivar identity: The identity of the cluster, if configured.
    :vartype identity: ~azure.mgmt.hdinsight.models.ClusterIdentity
    """

    location: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The location of the cluster."""
    tags: Optional[dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The resource tags."""
    zones: Optional[list[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The availability zones."""
    properties: Optional["_models.ClusterCreateProperties"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster create parameters."""
    identity: Optional["_models.ClusterIdentity"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The identity of the cluster, if configured."""

    @overload
    def __init__(
        self,
        *,
        location: Optional[str] = None,
        tags: Optional[dict[str, str]] = None,
        zones: Optional[list[str]] = None,
        properties: Optional["_models.ClusterCreateProperties"] = None,
        identity: Optional["_models.ClusterIdentity"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterCreateProperties(_Model):
    """The cluster create parameters.

    :ivar cluster_version: The version of the cluster.
    :vartype cluster_version: str
    :ivar os_type: The type of operating system. Known values are: "Windows" and "Linux".
    :vartype os_type: str or ~azure.mgmt.hdinsight.models.OSType
    :ivar tier: The cluster tier. Known values are: "Standard" and "Premium".
    :vartype tier: str or ~azure.mgmt.hdinsight.models.Tier
    :ivar cluster_definition: The cluster definition.
    :vartype cluster_definition: ~azure.mgmt.hdinsight.models.ClusterDefinition
    :ivar kafka_rest_properties: The cluster kafka rest proxy configuration.
    :vartype kafka_rest_properties: ~azure.mgmt.hdinsight.models.KafkaRestProperties
    :ivar security_profile: The security profile.
    :vartype security_profile: ~azure.mgmt.hdinsight.models.SecurityProfile
    :ivar compute_profile: The compute profile.
    :vartype compute_profile: ~azure.mgmt.hdinsight.models.ComputeProfile
    :ivar storage_profile: The storage profile.
    :vartype storage_profile: ~azure.mgmt.hdinsight.models.StorageProfile
    :ivar disk_encryption_properties: The disk encryption properties.
    :vartype disk_encryption_properties: ~azure.mgmt.hdinsight.models.DiskEncryptionProperties
    :ivar encryption_in_transit_properties: The encryption-in-transit properties.
    :vartype encryption_in_transit_properties:
     ~azure.mgmt.hdinsight.models.EncryptionInTransitProperties
    :ivar min_supported_tls_version: The minimal supported tls version.
    :vartype min_supported_tls_version: str
    :ivar network_properties: The network properties.
    :vartype network_properties: ~azure.mgmt.hdinsight.models.NetworkProperties
    :ivar compute_isolation_properties: The compute isolation properties.
    :vartype compute_isolation_properties: ~azure.mgmt.hdinsight.models.ComputeIsolationProperties
    :ivar private_link_configurations: The private link configurations.
    :vartype private_link_configurations:
     list[~azure.mgmt.hdinsight.models.PrivateLinkConfiguration]
    """

    cluster_version: Optional[str] = rest_field(
        name="clusterVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """The version of the cluster."""
    os_type: Optional[Union[str, "_models.OSType"]] = rest_field(
        name="osType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The type of operating system. Known values are: \"Windows\" and \"Linux\"."""
    tier: Optional[Union[str, "_models.Tier"]] = rest_field(visibility=["read", "create"])
    """The cluster tier. Known values are: \"Standard\" and \"Premium\"."""
    cluster_definition: Optional["_models.ClusterDefinition"] = rest_field(
        name="clusterDefinition", visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster definition."""
    kafka_rest_properties: Optional["_models.KafkaRestProperties"] = rest_field(
        name="kafkaRestProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster kafka rest proxy configuration."""
    security_profile: Optional["_models.SecurityProfile"] = rest_field(
        name="securityProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The security profile."""
    compute_profile: Optional["_models.ComputeProfile"] = rest_field(
        name="computeProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The compute profile."""
    storage_profile: Optional["_models.StorageProfile"] = rest_field(
        name="storageProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The storage profile."""
    disk_encryption_properties: Optional["_models.DiskEncryptionProperties"] = rest_field(
        name="diskEncryptionProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The disk encryption properties."""
    encryption_in_transit_properties: Optional["_models.EncryptionInTransitProperties"] = rest_field(
        name="encryptionInTransitProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The encryption-in-transit properties."""
    min_supported_tls_version: Optional[str] = rest_field(
        name="minSupportedTlsVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """The minimal supported tls version."""
    network_properties: Optional["_models.NetworkProperties"] = rest_field(
        name="networkProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The network properties."""
    compute_isolation_properties: Optional["_models.ComputeIsolationProperties"] = rest_field(
        name="computeIsolationProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The compute isolation properties."""
    private_link_configurations: Optional[list["_models.PrivateLinkConfiguration"]] = rest_field(
        name="privateLinkConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link configurations."""

    @overload
    def __init__(
        self,
        *,
        cluster_version: Optional[str] = None,
        os_type: Optional[Union[str, "_models.OSType"]] = None,
        tier: Optional[Union[str, "_models.Tier"]] = None,
        cluster_definition: Optional["_models.ClusterDefinition"] = None,
        kafka_rest_properties: Optional["_models.KafkaRestProperties"] = None,
        security_profile: Optional["_models.SecurityProfile"] = None,
        compute_profile: Optional["_models.ComputeProfile"] = None,
        storage_profile: Optional["_models.StorageProfile"] = None,
        disk_encryption_properties: Optional["_models.DiskEncryptionProperties"] = None,
        encryption_in_transit_properties: Optional["_models.EncryptionInTransitProperties"] = None,
        min_supported_tls_version: Optional[str] = None,
        network_properties: Optional["_models.NetworkProperties"] = None,
        compute_isolation_properties: Optional["_models.ComputeIsolationProperties"] = None,
        private_link_configurations: Optional[list["_models.PrivateLinkConfiguration"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterCreateRequestValidationParameters(ClusterCreateParametersExtended):
    """The cluster create request specification.

    :ivar location: The location of the cluster.
    :vartype location: str
    :ivar tags: The resource tags.
    :vartype tags: dict[str, str]
    :ivar zones: The availability zones.
    :vartype zones: list[str]
    :ivar properties: The cluster create parameters.
    :vartype properties: ~azure.mgmt.hdinsight.models.ClusterCreateProperties
    :ivar identity: The identity of the cluster, if configured.
    :vartype identity: ~azure.mgmt.hdinsight.models.ClusterIdentity
    :ivar name: The cluster name.
    :vartype name: str
    :ivar type: The resource type.
    :vartype type: str
    :ivar tenant_id: The tenant id.
    :vartype tenant_id: str
    :ivar fetch_aadds_resource: This indicates whether fetch Aadds resource or not.
    :vartype fetch_aadds_resource: bool
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The cluster name."""
    type: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The resource type."""
    tenant_id: Optional[str] = rest_field(name="tenantId", visibility=["read", "create", "update", "delete", "query"])
    """The tenant id."""
    fetch_aadds_resource: Optional[bool] = rest_field(
        name="fetchAaddsResource", visibility=["read", "create", "update", "delete", "query"]
    )
    """This indicates whether fetch Aadds resource or not."""

    @overload
    def __init__(
        self,
        *,
        location: Optional[str] = None,
        tags: Optional[dict[str, str]] = None,
        zones: Optional[list[str]] = None,
        properties: Optional["_models.ClusterCreateProperties"] = None,
        identity: Optional["_models.ClusterIdentity"] = None,
        name: Optional[str] = None,
        type: Optional[str] = None,
        tenant_id: Optional[str] = None,
        fetch_aadds_resource: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterCreateValidationResult(_Model):
    """The response of cluster create request validation.

    :ivar validation_errors: The validation errors.
    :vartype validation_errors: list[~azure.mgmt.hdinsight.models.ValidationErrorInfo]
    :ivar validation_warnings: The validation warnings.
    :vartype validation_warnings: list[~azure.mgmt.hdinsight.models.ValidationErrorInfo]
    :ivar estimated_creation_duration: The estimated creation duration.
    :vartype estimated_creation_duration: ~datetime.timedelta
    :ivar aadds_resources_details: The Azure active directory domain service resource details.
    :vartype aadds_resources_details: list[~azure.mgmt.hdinsight.models.AaddsResourceDetails]
    """

    validation_errors: Optional[list["_models.ValidationErrorInfo"]] = rest_field(
        name="validationErrors", visibility=["read", "create", "update", "delete", "query"]
    )
    """The validation errors."""
    validation_warnings: Optional[list["_models.ValidationErrorInfo"]] = rest_field(
        name="validationWarnings", visibility=["read", "create", "update", "delete", "query"]
    )
    """The validation warnings."""
    estimated_creation_duration: Optional[datetime.timedelta] = rest_field(
        name="estimatedCreationDuration", visibility=["read", "create", "update", "delete", "query"]
    )
    """The estimated creation duration."""
    aadds_resources_details: Optional[list["_models.AaddsResourceDetails"]] = rest_field(
        name="aaddsResourcesDetails", visibility=["read", "create", "update", "delete", "query"]
    )
    """The Azure active directory domain service resource details."""

    @overload
    def __init__(
        self,
        *,
        validation_errors: Optional[list["_models.ValidationErrorInfo"]] = None,
        validation_warnings: Optional[list["_models.ValidationErrorInfo"]] = None,
        estimated_creation_duration: Optional[datetime.timedelta] = None,
        aadds_resources_details: Optional[list["_models.AaddsResourceDetails"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterDefinition(_Model):
    """The cluster definition.

    :ivar blueprint: The link to the blueprint.
    :vartype blueprint: str
    :ivar kind: The type of cluster.
    :vartype kind: str
    :ivar component_version: The versions of different services in the cluster.
    :vartype component_version: dict[str, str]
    :ivar configurations: The cluster configurations.
    :vartype configurations: any
    """

    blueprint: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The link to the blueprint."""
    kind: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The type of cluster."""
    component_version: Optional[dict[str, str]] = rest_field(name="componentVersion", visibility=["read", "create"])
    """The versions of different services in the cluster."""
    configurations: Optional[Any] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The cluster configurations."""

    @overload
    def __init__(
        self,
        *,
        blueprint: Optional[str] = None,
        kind: Optional[str] = None,
        component_version: Optional[dict[str, str]] = None,
        configurations: Optional[Any] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterDiskEncryptionParameters(_Model):
    """The Disk Encryption Cluster request parameters.

    :ivar vault_uri: Base key vault URI where the customers key is located eg.
     `https://myvault.vault.azure.net <https://myvault.vault.azure.net>`_.
    :vartype vault_uri: str
    :ivar key_name: Key name that is used for enabling disk encryption.
    :vartype key_name: str
    :ivar key_version: Specific key version that is used for enabling disk encryption.
    :vartype key_version: str
    """

    vault_uri: Optional[str] = rest_field(name="vaultUri", visibility=["read", "create", "update", "delete", "query"])
    """Base key vault URI where the customers key is located eg. `https://myvault.vault.azure.net
     <https://myvault.vault.azure.net>`_."""
    key_name: Optional[str] = rest_field(name="keyName", visibility=["read", "create", "update", "delete", "query"])
    """Key name that is used for enabling disk encryption."""
    key_version: Optional[str] = rest_field(
        name="keyVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """Specific key version that is used for enabling disk encryption."""

    @overload
    def __init__(
        self,
        *,
        vault_uri: Optional[str] = None,
        key_name: Optional[str] = None,
        key_version: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterGetProperties(_Model):
    """The properties of cluster.

    :ivar cluster_version: The version of the cluster.
    :vartype cluster_version: str
    :ivar cluster_hdp_version: The hdp version of the cluster.
    :vartype cluster_hdp_version: str
    :ivar os_type: The type of operating system. Known values are: "Windows" and "Linux".
    :vartype os_type: str or ~azure.mgmt.hdinsight.models.OSType
    :ivar tier: The cluster tier. Known values are: "Standard" and "Premium".
    :vartype tier: str or ~azure.mgmt.hdinsight.models.Tier
    :ivar cluster_id: The cluster id.
    :vartype cluster_id: str
    :ivar cluster_definition: The cluster definition. Required.
    :vartype cluster_definition: ~azure.mgmt.hdinsight.models.ClusterDefinition
    :ivar kafka_rest_properties: The cluster kafka rest proxy configuration.
    :vartype kafka_rest_properties: ~azure.mgmt.hdinsight.models.KafkaRestProperties
    :ivar security_profile: The security profile.
    :vartype security_profile: ~azure.mgmt.hdinsight.models.SecurityProfile
    :ivar compute_profile: The compute profile.
    :vartype compute_profile: ~azure.mgmt.hdinsight.models.ComputeProfile
    :ivar provisioning_state: The provisioning state, which only appears in the response. Known
     values are: "InProgress", "Failed", "Succeeded", "Canceled", and "Deleting".
    :vartype provisioning_state: str or
     ~azure.mgmt.hdinsight.models.HDInsightClusterProvisioningState
    :ivar created_date: The date on which the cluster was created.
    :vartype created_date: str
    :ivar cluster_state: The state of the cluster.
    :vartype cluster_state: str
    :ivar quota_info: The quota information.
    :vartype quota_info: ~azure.mgmt.hdinsight.models.QuotaInfo
    :ivar errors: The list of errors.
    :vartype errors: list[~azure.mgmt.hdinsight.models.Errors]
    :ivar connectivity_endpoints: The list of connectivity endpoints.
    :vartype connectivity_endpoints: list[~azure.mgmt.hdinsight.models.ConnectivityEndpoint]
    :ivar disk_encryption_properties: The disk encryption properties.
    :vartype disk_encryption_properties: ~azure.mgmt.hdinsight.models.DiskEncryptionProperties
    :ivar encryption_in_transit_properties: The encryption-in-transit properties.
    :vartype encryption_in_transit_properties:
     ~azure.mgmt.hdinsight.models.EncryptionInTransitProperties
    :ivar storage_profile: The storage profile.
    :vartype storage_profile: ~azure.mgmt.hdinsight.models.StorageProfile
    :ivar min_supported_tls_version: The minimal supported tls version.
    :vartype min_supported_tls_version: str
    :ivar excluded_services_config: The excluded services config.
    :vartype excluded_services_config: ~azure.mgmt.hdinsight.models.ExcludedServicesConfig
    :ivar network_properties: The network properties.
    :vartype network_properties: ~azure.mgmt.hdinsight.models.NetworkProperties
    :ivar compute_isolation_properties: The compute isolation properties.
    :vartype compute_isolation_properties: ~azure.mgmt.hdinsight.models.ComputeIsolationProperties
    :ivar private_link_configurations: The private link configurations.
    :vartype private_link_configurations:
     list[~azure.mgmt.hdinsight.models.PrivateLinkConfiguration]
    :ivar private_endpoint_connections: The list of private endpoint connections.
    :vartype private_endpoint_connections:
     list[~azure.mgmt.hdinsight.models.PrivateEndpointConnection]
    """

    cluster_version: Optional[str] = rest_field(
        name="clusterVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """The version of the cluster."""
    cluster_hdp_version: Optional[str] = rest_field(
        name="clusterHdpVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """The hdp version of the cluster."""
    os_type: Optional[Union[str, "_models.OSType"]] = rest_field(
        name="osType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The type of operating system. Known values are: \"Windows\" and \"Linux\"."""
    tier: Optional[Union[str, "_models.Tier"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The cluster tier. Known values are: \"Standard\" and \"Premium\"."""
    cluster_id: Optional[str] = rest_field(name="clusterId", visibility=["read", "create", "update", "delete", "query"])
    """The cluster id."""
    cluster_definition: "_models.ClusterDefinition" = rest_field(
        name="clusterDefinition", visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster definition. Required."""
    kafka_rest_properties: Optional["_models.KafkaRestProperties"] = rest_field(
        name="kafkaRestProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster kafka rest proxy configuration."""
    security_profile: Optional["_models.SecurityProfile"] = rest_field(
        name="securityProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The security profile."""
    compute_profile: Optional["_models.ComputeProfile"] = rest_field(
        name="computeProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The compute profile."""
    provisioning_state: Optional[Union[str, "_models.HDInsightClusterProvisioningState"]] = rest_field(
        name="provisioningState", visibility=["read", "create", "update", "delete", "query"]
    )
    """The provisioning state, which only appears in the response. Known values are: \"InProgress\",
     \"Failed\", \"Succeeded\", \"Canceled\", and \"Deleting\"."""
    created_date: Optional[str] = rest_field(
        name="createdDate", visibility=["read", "create", "update", "delete", "query"]
    )
    """The date on which the cluster was created."""
    cluster_state: Optional[str] = rest_field(
        name="clusterState", visibility=["read", "create", "update", "delete", "query"]
    )
    """The state of the cluster."""
    quota_info: Optional["_models.QuotaInfo"] = rest_field(
        name="quotaInfo", visibility=["read", "create", "update", "delete", "query"]
    )
    """The quota information."""
    errors: Optional[list["_models.Errors"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The list of errors."""
    connectivity_endpoints: Optional[list["_models.ConnectivityEndpoint"]] = rest_field(
        name="connectivityEndpoints", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of connectivity endpoints."""
    disk_encryption_properties: Optional["_models.DiskEncryptionProperties"] = rest_field(
        name="diskEncryptionProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The disk encryption properties."""
    encryption_in_transit_properties: Optional["_models.EncryptionInTransitProperties"] = rest_field(
        name="encryptionInTransitProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The encryption-in-transit properties."""
    storage_profile: Optional["_models.StorageProfile"] = rest_field(
        name="storageProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The storage profile."""
    min_supported_tls_version: Optional[str] = rest_field(
        name="minSupportedTlsVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """The minimal supported tls version."""
    excluded_services_config: Optional["_models.ExcludedServicesConfig"] = rest_field(
        name="excludedServicesConfig", visibility=["read", "create", "update", "delete", "query"]
    )
    """The excluded services config."""
    network_properties: Optional["_models.NetworkProperties"] = rest_field(
        name="networkProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The network properties."""
    compute_isolation_properties: Optional["_models.ComputeIsolationProperties"] = rest_field(
        name="computeIsolationProperties", visibility=["read", "create", "update", "delete", "query"]
    )
    """The compute isolation properties."""
    private_link_configurations: Optional[list["_models.PrivateLinkConfiguration"]] = rest_field(
        name="privateLinkConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link configurations."""
    private_endpoint_connections: Optional[list["_models.PrivateEndpointConnection"]] = rest_field(
        name="privateEndpointConnections", visibility=["read"]
    )
    """The list of private endpoint connections."""

    @overload
    def __init__(
        self,
        *,
        cluster_definition: "_models.ClusterDefinition",
        cluster_version: Optional[str] = None,
        cluster_hdp_version: Optional[str] = None,
        os_type: Optional[Union[str, "_models.OSType"]] = None,
        tier: Optional[Union[str, "_models.Tier"]] = None,
        cluster_id: Optional[str] = None,
        kafka_rest_properties: Optional["_models.KafkaRestProperties"] = None,
        security_profile: Optional["_models.SecurityProfile"] = None,
        compute_profile: Optional["_models.ComputeProfile"] = None,
        provisioning_state: Optional[Union[str, "_models.HDInsightClusterProvisioningState"]] = None,
        created_date: Optional[str] = None,
        cluster_state: Optional[str] = None,
        quota_info: Optional["_models.QuotaInfo"] = None,
        errors: Optional[list["_models.Errors"]] = None,
        connectivity_endpoints: Optional[list["_models.ConnectivityEndpoint"]] = None,
        disk_encryption_properties: Optional["_models.DiskEncryptionProperties"] = None,
        encryption_in_transit_properties: Optional["_models.EncryptionInTransitProperties"] = None,
        storage_profile: Optional["_models.StorageProfile"] = None,
        min_supported_tls_version: Optional[str] = None,
        excluded_services_config: Optional["_models.ExcludedServicesConfig"] = None,
        network_properties: Optional["_models.NetworkProperties"] = None,
        compute_isolation_properties: Optional["_models.ComputeIsolationProperties"] = None,
        private_link_configurations: Optional[list["_models.PrivateLinkConfiguration"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterIdentity(_Model):
    """Identity for the cluster.

    :ivar principal_id: The principal id of cluster identity. This property will only be provided
     for a system assigned identity.
    :vartype principal_id: str
    :ivar tenant_id: The tenant id associated with the cluster. This property will only be provided
     for a system assigned identity.
    :vartype tenant_id: str
    :ivar type: The type of identity used for the cluster. The type 'SystemAssigned, UserAssigned'
     includes both an implicitly created identity and a set of user assigned identities. Known
     values are: "SystemAssigned", "UserAssigned", "SystemAssigned, UserAssigned", and "None".
    :vartype type: str or ~azure.mgmt.hdinsight.models.ResourceIdentityType
    :ivar user_assigned_identities: The list of user identities associated with the cluster. The
     user identity dictionary key references will be ARM resource ids in the form:
     '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
    :vartype user_assigned_identities: dict[str, ~azure.mgmt.hdinsight.models.UserAssignedIdentity]
    """

    principal_id: Optional[str] = rest_field(name="principalId", visibility=["read"])
    """The principal id of cluster identity. This property will only be provided for a system assigned
     identity."""
    tenant_id: Optional[str] = rest_field(name="tenantId", visibility=["read"])
    """The tenant id associated with the cluster. This property will only be provided for a system
     assigned identity."""
    type: Optional[Union[str, "_models.ResourceIdentityType"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The type of identity used for the cluster. The type 'SystemAssigned, UserAssigned' includes
     both an implicitly created identity and a set of user assigned identities. Known values are:
     \"SystemAssigned\", \"UserAssigned\", \"SystemAssigned, UserAssigned\", and \"None\"."""
    user_assigned_identities: Optional[dict[str, "_models.UserAssignedIdentity"]] = rest_field(
        name="userAssignedIdentities", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of user identities associated with the cluster. The user identity dictionary key
     references will be ARM resource ids in the form:
     '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'."""

    @overload
    def __init__(
        self,
        *,
        type: Optional[Union[str, "_models.ResourceIdentityType"]] = None,
        user_assigned_identities: Optional[dict[str, "_models.UserAssignedIdentity"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterMonitoringRequest(_Model):
    """The cluster monitor parameters.

    :ivar workspace_id: The cluster monitor workspace ID.
    :vartype workspace_id: str
    :ivar primary_key: The cluster monitor workspace key.
    :vartype primary_key: str
    """

    workspace_id: Optional[str] = rest_field(
        name="workspaceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster monitor workspace ID."""
    primary_key: Optional[str] = rest_field(
        name="primaryKey", visibility=["read", "create", "update", "delete", "query"]
    )
    """The cluster monitor workspace key."""

    @overload
    def __init__(
        self,
        *,
        workspace_id: Optional[str] = None,
        primary_key: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterMonitoringResponse(_Model):
    """The cluster monitoring status response.

    :ivar cluster_monitoring_enabled: The status of the monitor on the HDInsight cluster.
    :vartype cluster_monitoring_enabled: bool
    :ivar workspace_id: The workspace ID of the monitor on the HDInsight cluster.
    :vartype workspace_id: str
    """

    cluster_monitoring_enabled: Optional[bool] = rest_field(
        name="clusterMonitoringEnabled", visibility=["read", "create", "update", "delete", "query"]
    )
    """The status of the monitor on the HDInsight cluster."""
    workspace_id: Optional[str] = rest_field(
        name="workspaceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The workspace ID of the monitor on the HDInsight cluster."""

    @overload
    def __init__(
        self,
        *,
        cluster_monitoring_enabled: Optional[bool] = None,
        workspace_id: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterPatchParameters(_Model):
    """The PatchCluster request parameters.

    :ivar tags: The resource tags.
    :vartype tags: dict[str, str]
    :ivar identity: The identity of the cluster, if configured. Setting this property will override
     the existing identity configuration of the cluster.
    :vartype identity: ~azure.mgmt.hdinsight.models.ClusterIdentity
    """

    tags: Optional[dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The resource tags."""
    identity: Optional["_models.ClusterIdentity"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The identity of the cluster, if configured. Setting this property will override the existing
     identity configuration of the cluster."""

    @overload
    def __init__(
        self,
        *,
        tags: Optional[dict[str, str]] = None,
        identity: Optional["_models.ClusterIdentity"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ClusterResizeParameters(_Model):
    """The Resize Cluster request parameters.

    :ivar target_instance_count: The target instance count for the operation.
    :vartype target_instance_count: int
    """

    target_instance_count: Optional[int] = rest_field(
        name="targetInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The target instance count for the operation."""

    @overload
    def __init__(
        self,
        *,
        target_instance_count: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ComputeIsolationProperties(_Model):
    """The compute isolation properties.

    :ivar enable_compute_isolation: The flag indicates whether enable compute isolation or not.
    :vartype enable_compute_isolation: bool
    :ivar host_sku: The host sku.
    :vartype host_sku: str
    """

    enable_compute_isolation: Optional[bool] = rest_field(
        name="enableComputeIsolation", visibility=["read", "create", "update", "delete", "query"]
    )
    """The flag indicates whether enable compute isolation or not."""
    host_sku: Optional[str] = rest_field(name="hostSku", visibility=["read", "create", "update", "delete", "query"])
    """The host sku."""

    @overload
    def __init__(
        self,
        *,
        enable_compute_isolation: Optional[bool] = None,
        host_sku: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ComputeProfile(_Model):
    """Describes the compute profile.

    :ivar roles: The list of roles in the cluster.
    :vartype roles: list[~azure.mgmt.hdinsight.models.Role]
    """

    roles: Optional[list["_models.Role"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The list of roles in the cluster."""

    @overload
    def __init__(
        self,
        *,
        roles: Optional[list["_models.Role"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ConnectivityEndpoint(_Model):
    """The connectivity properties.

    :ivar name: The name of the endpoint.
    :vartype name: str
    :ivar protocol: The protocol of the endpoint.
    :vartype protocol: str
    :ivar location: The location of the endpoint.
    :vartype location: str
    :ivar port: The port to connect to.
    :vartype port: int
    :ivar private_ip_address: The private ip address of the endpoint.
    :vartype private_ip_address: str
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the endpoint."""
    protocol: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The protocol of the endpoint."""
    location: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The location of the endpoint."""
    port: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The port to connect to."""
    private_ip_address: Optional[str] = rest_field(
        name="privateIPAddress", visibility=["read", "create", "update", "delete", "query"]
    )
    """The private ip address of the endpoint."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        protocol: Optional[str] = None,
        location: Optional[str] = None,
        port: Optional[int] = None,
        private_ip_address: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class DataDisksGroups(_Model):
    """The data disks groups for the role.

    :ivar disks_per_node: The number of disks per node.
    :vartype disks_per_node: int
    :ivar storage_account_type: ReadOnly. The storage account type. Do not set this value.
    :vartype storage_account_type: str
    :ivar disk_size_gb: ReadOnly. The DiskSize in GB. Do not set this value.
    :vartype disk_size_gb: int
    """

    disks_per_node: Optional[int] = rest_field(
        name="disksPerNode", visibility=["read", "create", "update", "delete", "query"]
    )
    """The number of disks per node."""
    storage_account_type: Optional[str] = rest_field(name="storageAccountType", visibility=["read"])
    """ReadOnly. The storage account type. Do not set this value."""
    disk_size_gb: Optional[int] = rest_field(name="diskSizeGB", visibility=["read"])
    """ReadOnly. The DiskSize in GB. Do not set this value."""

    @overload
    def __init__(
        self,
        *,
        disks_per_node: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Dimension(_Model):
    """The definition of Dimension.

    :ivar name: The name of the dimension.
    :vartype name: str
    :ivar display_name: The display name of the dimension.
    :vartype display_name: str
    :ivar internal_name: The display name of the dimension.
    :vartype internal_name: str
    :ivar to_be_exported_for_shoebox: The flag indicates whether the metric will be exported for
     shoebox or not.
    :vartype to_be_exported_for_shoebox: bool
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the dimension."""
    display_name: Optional[str] = rest_field(
        name="displayName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The display name of the dimension."""
    internal_name: Optional[str] = rest_field(
        name="internalName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The display name of the dimension."""
    to_be_exported_for_shoebox: Optional[bool] = rest_field(
        name="toBeExportedForShoebox", visibility=["read", "create", "update", "delete", "query"]
    )
    """The flag indicates whether the metric will be exported for shoebox or not."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display_name: Optional[str] = None,
        internal_name: Optional[str] = None,
        to_be_exported_for_shoebox: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class DiskBillingMeters(_Model):
    """The disk billing meters.

    :ivar disk_rp_meter: The managed disk meter guid.
    :vartype disk_rp_meter: str
    :ivar sku: The managed disk billing sku, P30 or S30.
    :vartype sku: str
    :ivar tier: The managed disk billing tier, Standard or Premium. Known values are: "Standard"
     and "Premium".
    :vartype tier: str or ~azure.mgmt.hdinsight.models.Tier
    """

    disk_rp_meter: Optional[str] = rest_field(
        name="diskRpMeter", visibility=["read", "create", "update", "delete", "query"]
    )
    """The managed disk meter guid."""
    sku: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The managed disk billing sku, P30 or S30."""
    tier: Optional[Union[str, "_models.Tier"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The managed disk billing tier, Standard or Premium. Known values are: \"Standard\" and
     \"Premium\"."""

    @overload
    def __init__(
        self,
        *,
        disk_rp_meter: Optional[str] = None,
        sku: Optional[str] = None,
        tier: Optional[Union[str, "_models.Tier"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class DiskEncryptionProperties(_Model):
    """The disk encryption properties.

    :ivar vault_uri: Base key vault URI where the customers key is located eg.
     `https://myvault.vault.azure.net <https://myvault.vault.azure.net>`_.
    :vartype vault_uri: str
    :ivar key_name: Key name that is used for enabling disk encryption.
    :vartype key_name: str
    :ivar key_version: Specific key version that is used for enabling disk encryption.
    :vartype key_version: str
    :ivar encryption_algorithm: Algorithm identifier for encryption, default RSA-OAEP. Known values
     are: "RSA-OAEP", "RSA-OAEP-256", and "RSA1_5".
    :vartype encryption_algorithm: str or
     ~azure.mgmt.hdinsight.models.JsonWebKeyEncryptionAlgorithm
    :ivar msi_resource_id: Resource ID of Managed Identity that is used to access the key vault.
    :vartype msi_resource_id: str
    :ivar encryption_at_host: Indicates whether or not resource disk encryption is enabled.
    :vartype encryption_at_host: bool
    """

    vault_uri: Optional[str] = rest_field(name="vaultUri", visibility=["read", "create", "update", "delete", "query"])
    """Base key vault URI where the customers key is located eg. `https://myvault.vault.azure.net
     <https://myvault.vault.azure.net>`_."""
    key_name: Optional[str] = rest_field(name="keyName", visibility=["read", "create", "update", "delete", "query"])
    """Key name that is used for enabling disk encryption."""
    key_version: Optional[str] = rest_field(
        name="keyVersion", visibility=["read", "create", "update", "delete", "query"]
    )
    """Specific key version that is used for enabling disk encryption."""
    encryption_algorithm: Optional[Union[str, "_models.JsonWebKeyEncryptionAlgorithm"]] = rest_field(
        name="encryptionAlgorithm", visibility=["read", "create", "update", "delete", "query"]
    )
    """Algorithm identifier for encryption, default RSA-OAEP. Known values are: \"RSA-OAEP\",
     \"RSA-OAEP-256\", and \"RSA1_5\"."""
    msi_resource_id: Optional[str] = rest_field(
        name="msiResourceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """Resource ID of Managed Identity that is used to access the key vault."""
    encryption_at_host: Optional[bool] = rest_field(
        name="encryptionAtHost", visibility=["read", "create", "update", "delete", "query"]
    )
    """Indicates whether or not resource disk encryption is enabled."""

    @overload
    def __init__(
        self,
        *,
        vault_uri: Optional[str] = None,
        key_name: Optional[str] = None,
        key_version: Optional[str] = None,
        encryption_algorithm: Optional[Union[str, "_models.JsonWebKeyEncryptionAlgorithm"]] = None,
        msi_resource_id: Optional[str] = None,
        encryption_at_host: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class EncryptionInTransitProperties(_Model):
    """The encryption-in-transit properties.

    :ivar is_encryption_in_transit_enabled: Indicates whether or not inter cluster node
     communication is encrypted in transit.
    :vartype is_encryption_in_transit_enabled: bool
    """

    is_encryption_in_transit_enabled: Optional[bool] = rest_field(
        name="isEncryptionInTransitEnabled", visibility=["read", "create", "update", "delete", "query"]
    )
    """Indicates whether or not inter cluster node communication is encrypted in transit."""

    @overload
    def __init__(
        self,
        *,
        is_encryption_in_transit_enabled: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class EntraUserInfo(_Model):
    """Details of an Entra user for gateway access.

    :ivar object_id: The unique object ID of the Entra user or client ID of the enterprise
     applications.
    :vartype object_id: str
    :ivar display_name: The display name of the Entra user.
    :vartype display_name: str
    :ivar upn: The User Principal Name (UPN) of the Entra user. It may be empty in certain cases,
     such as for enterprise applications.
    :vartype upn: str
    """

    object_id: Optional[str] = rest_field(name="objectId", visibility=["read", "create", "update", "delete", "query"])
    """The unique object ID of the Entra user or client ID of the enterprise applications."""
    display_name: Optional[str] = rest_field(
        name="displayName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The display name of the Entra user."""
    upn: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The User Principal Name (UPN) of the Entra user. It may be empty in certain cases, such as for
     enterprise applications."""

    @overload
    def __init__(
        self,
        *,
        object_id: Optional[str] = None,
        display_name: Optional[str] = None,
        upn: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ErrorResponse(_Model):
    """Describes the format of Error response.

    :ivar code: Error code.
    :vartype code: str
    :ivar message: Error message indicating why the operation failed.
    :vartype message: str
    """

    code: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """Error code."""
    message: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """Error message indicating why the operation failed."""

    @overload
    def __init__(
        self,
        *,
        code: Optional[str] = None,
        message: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Errors(_Model):
    """The error message associated with the cluster creation.

    :ivar code: The error code.
    :vartype code: str
    :ivar message: The error message.
    :vartype message: str
    """

    code: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The error code."""
    message: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The error message."""

    @overload
    def __init__(
        self,
        *,
        code: Optional[str] = None,
        message: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ExcludedServicesConfig(_Model):
    """The configuration that services will be excluded when creating cluster.

    :ivar excluded_services_config_id: The config id of excluded services.
    :vartype excluded_services_config_id: str
    :ivar excluded_services_list: The list of excluded services.
    :vartype excluded_services_list: str
    """

    excluded_services_config_id: Optional[str] = rest_field(
        name="excludedServicesConfigId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The config id of excluded services."""
    excluded_services_list: Optional[str] = rest_field(
        name="excludedServicesList", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of excluded services."""

    @overload
    def __init__(
        self,
        *,
        excluded_services_config_id: Optional[str] = None,
        excluded_services_list: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ExecuteScriptActionParameters(_Model):
    """The parameters for the script actions to execute on a running cluster.

    :ivar script_actions: The list of run time script actions.
    :vartype script_actions: list[~azure.mgmt.hdinsight.models.RuntimeScriptAction]
    :ivar persist_on_success: Gets or sets if the scripts needs to be persisted. Required.
    :vartype persist_on_success: bool
    """

    script_actions: Optional[list["_models.RuntimeScriptAction"]] = rest_field(
        name="scriptActions", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of run time script actions."""
    persist_on_success: bool = rest_field(
        name="persistOnSuccess", visibility=["read", "create", "update", "delete", "query"]
    )
    """Gets or sets if the scripts needs to be persisted. Required."""

    @overload
    def __init__(
        self,
        *,
        persist_on_success: bool,
        script_actions: Optional[list["_models.RuntimeScriptAction"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Extension(_Model):
    """Cluster monitoring extensions.

    :ivar workspace_id: The workspace ID for the cluster monitoring extension.
    :vartype workspace_id: str
    :ivar primary_key: The certificate for the cluster monitoring extensions.
    :vartype primary_key: str
    """

    workspace_id: Optional[str] = rest_field(
        name="workspaceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The workspace ID for the cluster monitoring extension."""
    primary_key: Optional[str] = rest_field(
        name="primaryKey", visibility=["read", "create", "update", "delete", "query"]
    )
    """The certificate for the cluster monitoring extensions."""

    @overload
    def __init__(
        self,
        *,
        workspace_id: Optional[str] = None,
        primary_key: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class GatewaySettings(_Model):
    """Gateway settings.

    :ivar is_credential_enabled: Indicates whether or not the gateway settings based authorization
     is enabled.
    :vartype is_credential_enabled: str
    :ivar user_name: The gateway settings user name.
    :vartype user_name: str
    :ivar password: The gateway settings user password.
    :vartype password: str
    :ivar rest_auth_entra_users: List of Entra users for gateway access.
    :vartype rest_auth_entra_users: list[~azure.mgmt.hdinsight.models.EntraUserInfo]
    """

    is_credential_enabled: Optional[str] = rest_field(name="restAuthCredential.isEnabled", visibility=["read"])
    """Indicates whether or not the gateway settings based authorization is enabled."""
    user_name: Optional[str] = rest_field(name="restAuthCredential.username", visibility=["read"])
    """The gateway settings user name."""
    password: Optional[str] = rest_field(name="restAuthCredential.password", visibility=["read"])
    """The gateway settings user password."""
    rest_auth_entra_users: Optional[list["_models.EntraUserInfo"]] = rest_field(
        name="restAuthEntraUsers", visibility=["read", "create", "update", "delete", "query"]
    )
    """List of Entra users for gateway access."""

    @overload
    def __init__(
        self,
        *,
        rest_auth_entra_users: Optional[list["_models.EntraUserInfo"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class HardwareProfile(_Model):
    """The hardware profile.

    :ivar vm_size: The size of the VM.
    :vartype vm_size: str
    """

    vm_size: Optional[str] = rest_field(name="vmSize", visibility=["read", "create", "update", "delete", "query"])
    """The size of the VM."""

    @overload
    def __init__(
        self,
        *,
        vm_size: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class HostInfo(_Model):
    """The cluster host information.

    :ivar name: The host name.
    :vartype name: str
    :ivar fqdn: The Fully Qualified Domain Name of host.
    :vartype fqdn: str
    :ivar effective_disk_encryption_key_url: The effective disk encryption key URL used by the
     host.
    :vartype effective_disk_encryption_key_url: str
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The host name."""
    fqdn: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The Fully Qualified Domain Name of host."""
    effective_disk_encryption_key_url: Optional[str] = rest_field(
        name="effectiveDiskEncryptionKeyUrl", visibility=["read", "create", "update", "delete", "query"]
    )
    """The effective disk encryption key URL used by the host."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        fqdn: Optional[str] = None,
        effective_disk_encryption_key_url: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class IPConfiguration(_Model):
    """The ip configurations for the private link service.

    :ivar id: The private link IP configuration id.
    :vartype id: str
    :ivar name: The name of private link IP configuration. Required.
    :vartype name: str
    :ivar type: The type of the private link IP configuration.
    :vartype type: str
    :ivar properties: The private link ip configuration properties.
    :vartype properties: ~azure.mgmt.hdinsight.models.IPConfigurationProperties
    """

    id: Optional[str] = rest_field(visibility=["read"])
    """The private link IP configuration id."""
    name: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of private link IP configuration. Required."""
    type: Optional[str] = rest_field(visibility=["read"])
    """The type of the private link IP configuration."""
    properties: Optional["_models.IPConfigurationProperties"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link ip configuration properties."""

    __flattened_items = [
        "provisioning_state",
        "primary",
        "private_ip_address",
        "private_ip_allocation_method",
        "subnet",
    ]

    @overload
    def __init__(
        self,
        *,
        name: str,
        properties: Optional["_models.IPConfigurationProperties"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}
        super().__init__(*args, **kwargs)
        for k, v in _flattened_input.items():
            setattr(self, k, v)

    def __getattr__(self, name: str) -> Any:
        if name in self.__flattened_items:
            if self.properties is None:
                return None
            return getattr(self.properties, name)
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

    def __setattr__(self, key: str, value: Any) -> None:
        if key in self.__flattened_items:
            if self.properties is None:
                self.properties = self._attr_to_rest_field["properties"]._class_type()
            setattr(self.properties, key, value)
        else:
            super().__setattr__(key, value)


class IPConfigurationProperties(_Model):
    """The private link ip configuration properties.

    :ivar provisioning_state: The private link configuration provisioning state, which only appears
     in the response. Known values are: "InProgress", "Failed", "Succeeded", "Canceled", and
     "Deleting".
    :vartype provisioning_state: str or
     ~azure.mgmt.hdinsight.models.PrivateLinkConfigurationProvisioningState
    :ivar primary: Indicates whether this IP configuration is primary for the corresponding NIC.
    :vartype primary: bool
    :ivar private_ip_address: The IP address.
    :vartype private_ip_address: str
    :ivar private_ip_allocation_method: The method that private IP address is allocated. Known
     values are: "dynamic" and "static".
    :vartype private_ip_allocation_method: str or
     ~azure.mgmt.hdinsight.models.PrivateIPAllocationMethod
    :ivar subnet: The subnet resource id.
    :vartype subnet: ~azure.mgmt.hdinsight.models.ResourceId
    """

    provisioning_state: Optional[Union[str, "_models.PrivateLinkConfigurationProvisioningState"]] = rest_field(
        name="provisioningState", visibility=["read"]
    )
    """The private link configuration provisioning state, which only appears in the response. Known
     values are: \"InProgress\", \"Failed\", \"Succeeded\", \"Canceled\", and \"Deleting\"."""
    primary: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """Indicates whether this IP configuration is primary for the corresponding NIC."""
    private_ip_address: Optional[str] = rest_field(
        name="privateIPAddress", visibility=["read", "create", "update", "delete", "query"]
    )
    """The IP address."""
    private_ip_allocation_method: Optional[Union[str, "_models.PrivateIPAllocationMethod"]] = rest_field(
        name="privateIPAllocationMethod", visibility=["read", "create", "update", "delete", "query"]
    )
    """The method that private IP address is allocated. Known values are: \"dynamic\" and \"static\"."""
    subnet: Optional["_models.ResourceId"] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The subnet resource id."""

    @overload
    def __init__(
        self,
        *,
        primary: Optional[bool] = None,
        private_ip_address: Optional[str] = None,
        private_ip_allocation_method: Optional[Union[str, "_models.PrivateIPAllocationMethod"]] = None,
        subnet: Optional["_models.ResourceId"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class IpTag(_Model):
    """Contains the IpTag associated with the public IP address.

    :ivar ip_tag_type: Gets or sets the ipTag type: Example FirstPartyUsage. Required.
    :vartype ip_tag_type: str
    :ivar tag: Gets or sets value of the IpTag associated with the public IP. Example HDInsight,
     SQL, Storage etc. Required.
    :vartype tag: str
    """

    ip_tag_type: str = rest_field(name="ipTagType", visibility=["read", "create", "update", "delete", "query"])
    """Gets or sets the ipTag type: Example FirstPartyUsage. Required."""
    tag: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """Gets or sets value of the IpTag associated with the public IP. Example HDInsight, SQL, Storage
     etc. Required."""

    @overload
    def __init__(
        self,
        *,
        ip_tag_type: str,
        tag: str,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class KafkaRestProperties(_Model):
    """The kafka rest proxy configuration which contains AAD security group information.

    :ivar client_group_info: The information of AAD security group.
    :vartype client_group_info: ~azure.mgmt.hdinsight.models.ClientGroupInfo
    :ivar configuration_override: The configurations that need to be overriden.
    :vartype configuration_override: dict[str, str]
    """

    client_group_info: Optional["_models.ClientGroupInfo"] = rest_field(
        name="clientGroupInfo", visibility=["read", "create", "update", "delete", "query"]
    )
    """The information of AAD security group."""
    configuration_override: Optional[dict[str, str]] = rest_field(
        name="configurationOverride", visibility=["read", "create", "update", "delete", "query"]
    )
    """The configurations that need to be overriden."""

    @overload
    def __init__(
        self,
        *,
        client_group_info: Optional["_models.ClientGroupInfo"] = None,
        configuration_override: Optional[dict[str, str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class LinuxOperatingSystemProfile(_Model):
    """The ssh username, password, and ssh public key.

    :ivar username: The username.
    :vartype username: str
    :ivar password: The password.
    :vartype password: str
    :ivar ssh_profile: The SSH profile.
    :vartype ssh_profile: ~azure.mgmt.hdinsight.models.SshProfile
    """

    username: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The username."""
    password: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The password."""
    ssh_profile: Optional["_models.SshProfile"] = rest_field(
        name="sshProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The SSH profile."""

    @overload
    def __init__(
        self,
        *,
        username: Optional[str] = None,
        password: Optional[str] = None,
        ssh_profile: Optional["_models.SshProfile"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class LocalizedName(_Model):
    """The details about the localizable name of a type of usage.

    :ivar value: The name of the used resource.
    :vartype value: str
    :ivar localized_value: The localized name of the used resource.
    :vartype localized_value: str
    """

    value: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the used resource."""
    localized_value: Optional[str] = rest_field(
        name="localizedValue", visibility=["read", "create", "update", "delete", "query"]
    )
    """The localized name of the used resource."""

    @overload
    def __init__(
        self,
        *,
        value: Optional[str] = None,
        localized_value: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class MetricSpecifications(_Model):
    """The details of metric specifications.

    :ivar name: The name of the metric specification.
    :vartype name: str
    :ivar display_name: The display name of the metric specification.
    :vartype display_name: str
    :ivar display_description: The display description of the metric specification.
    :vartype display_description: str
    :ivar unit: The unit of the metric specification.
    :vartype unit: str
    :ivar aggregation_type: The aggregation type of the metric specification.
    :vartype aggregation_type: str
    :ivar supported_aggregation_types: The supported aggregation types of the metric specification.
    :vartype supported_aggregation_types: list[str]
    :ivar supported_time_grain_types: The supported time grain types of the metric specification.
    :vartype supported_time_grain_types: list[str]
    :ivar enable_regional_mdm_account: The flag indicates whether enable regional mdm account or
     not.
    :vartype enable_regional_mdm_account: bool
    :ivar source_mdm_account: The source mdm account.
    :vartype source_mdm_account: str
    :ivar source_mdm_namespace: The source mdm namespace.
    :vartype source_mdm_namespace: str
    :ivar metric_filter_pattern: The metric filter pattern.
    :vartype metric_filter_pattern: str
    :ivar fill_gap_with_zero: The flag indicates whether filling gap with zero.
    :vartype fill_gap_with_zero: bool
    :ivar category: The category of the metric.
    :vartype category: str
    :ivar resource_id_dimension_name_override: The override name of resource id dimension name.
    :vartype resource_id_dimension_name_override: str
    :ivar is_internal: The flag indicates whether the metric is internal or not.
    :vartype is_internal: bool
    :ivar delegate_metric_name_override: The override name of delegate metric.
    :vartype delegate_metric_name_override: str
    :ivar dimensions: The dimensions of the metric specification.
    :vartype dimensions: list[~azure.mgmt.hdinsight.models.Dimension]
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the metric specification."""
    display_name: Optional[str] = rest_field(
        name="displayName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The display name of the metric specification."""
    display_description: Optional[str] = rest_field(
        name="displayDescription", visibility=["read", "create", "update", "delete", "query"]
    )
    """The display description of the metric specification."""
    unit: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The unit of the metric specification."""
    aggregation_type: Optional[str] = rest_field(
        name="aggregationType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The aggregation type of the metric specification."""
    supported_aggregation_types: Optional[list[str]] = rest_field(
        name="supportedAggregationTypes", visibility=["read", "create", "update", "delete", "query"]
    )
    """The supported aggregation types of the metric specification."""
    supported_time_grain_types: Optional[list[str]] = rest_field(
        name="supportedTimeGrainTypes", visibility=["read", "create", "update", "delete", "query"]
    )
    """The supported time grain types of the metric specification."""
    enable_regional_mdm_account: Optional[bool] = rest_field(
        name="enableRegionalMdmAccount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The flag indicates whether enable regional mdm account or not."""
    source_mdm_account: Optional[str] = rest_field(
        name="sourceMdmAccount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The source mdm account."""
    source_mdm_namespace: Optional[str] = rest_field(
        name="sourceMdmNamespace", visibility=["read", "create", "update", "delete", "query"]
    )
    """The source mdm namespace."""
    metric_filter_pattern: Optional[str] = rest_field(
        name="metricFilterPattern", visibility=["read", "create", "update", "delete", "query"]
    )
    """The metric filter pattern."""
    fill_gap_with_zero: Optional[bool] = rest_field(
        name="fillGapWithZero", visibility=["read", "create", "update", "delete", "query"]
    )
    """The flag indicates whether filling gap with zero."""
    category: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The category of the metric."""
    resource_id_dimension_name_override: Optional[str] = rest_field(
        name="resourceIdDimensionNameOverride", visibility=["read", "create", "update", "delete", "query"]
    )
    """The override name of resource id dimension name."""
    is_internal: Optional[bool] = rest_field(
        name="isInternal", visibility=["read", "create", "update", "delete", "query"]
    )
    """The flag indicates whether the metric is internal or not."""
    delegate_metric_name_override: Optional[str] = rest_field(
        name="delegateMetricNameOverride", visibility=["read", "create", "update", "delete", "query"]
    )
    """The override name of delegate metric."""
    dimensions: Optional[list["_models.Dimension"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The dimensions of the metric specification."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display_name: Optional[str] = None,
        display_description: Optional[str] = None,
        unit: Optional[str] = None,
        aggregation_type: Optional[str] = None,
        supported_aggregation_types: Optional[list[str]] = None,
        supported_time_grain_types: Optional[list[str]] = None,
        enable_regional_mdm_account: Optional[bool] = None,
        source_mdm_account: Optional[str] = None,
        source_mdm_namespace: Optional[str] = None,
        metric_filter_pattern: Optional[str] = None,
        fill_gap_with_zero: Optional[bool] = None,
        category: Optional[str] = None,
        resource_id_dimension_name_override: Optional[str] = None,
        is_internal: Optional[bool] = None,
        delegate_metric_name_override: Optional[str] = None,
        dimensions: Optional[list["_models.Dimension"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class NameAvailabilityCheckRequestParameters(_Model):
    """The request spec of checking name availability.

    :ivar name: The resource name.
    :vartype name: str
    :ivar type: The resource type.
    :vartype type: str
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The resource name."""
    type: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The resource type."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        type: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class NameAvailabilityCheckResult(_Model):
    """The response spec of checking name availability.

    :ivar name_available: This indicates whether the name is available.
    :vartype name_available: bool
    :ivar reason: The reason of the result.
    :vartype reason: str
    :ivar message: The related message.
    :vartype message: str
    """

    name_available: Optional[bool] = rest_field(
        name="nameAvailable", visibility=["read", "create", "update", "delete", "query"]
    )
    """This indicates whether the name is available."""
    reason: Optional[str] = rest_field(visibility=["read"])
    """The reason of the result."""
    message: Optional[str] = rest_field(visibility=["read"])
    """The related message."""

    @overload
    def __init__(
        self,
        *,
        name_available: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class NetworkProperties(_Model):
    """The network properties.

    :ivar outbound_dependencies_managed_type: A value to describe how the outbound dependencies of
     a HDInsight cluster are managed. 'Managed' means that the outbound dependencies are managed by
     the HDInsight service. 'External' means that the outbound dependencies are managed by a
     customer specific solution. Known values are: "Managed" and "External".
    :vartype outbound_dependencies_managed_type: str or
     ~azure.mgmt.hdinsight.models.OutboundDependenciesManagedType
    :ivar resource_provider_connection: The direction for the resource provider connection. Known
     values are: "Inbound" and "Outbound".
    :vartype resource_provider_connection: str or
     ~azure.mgmt.hdinsight.models.ResourceProviderConnection
    :ivar private_link: Indicates whether or not private link is enabled. Known values are:
     "Disabled" and "Enabled".
    :vartype private_link: str or ~azure.mgmt.hdinsight.models.PrivateLink
    :ivar public_ip_tag: Gets or sets the IP tag for the public IPs created along with the
     HDInsight Clusters.
    :vartype public_ip_tag: ~azure.mgmt.hdinsight.models.IpTag
    """

    outbound_dependencies_managed_type: Optional[Union[str, "_models.OutboundDependenciesManagedType"]] = rest_field(
        name="outboundDependenciesManagedType", visibility=["read", "create", "update", "delete", "query"]
    )
    """A value to describe how the outbound dependencies of a HDInsight cluster are managed. 'Managed'
     means that the outbound dependencies are managed by the HDInsight service. 'External' means
     that the outbound dependencies are managed by a customer specific solution. Known values are:
     \"Managed\" and \"External\"."""
    resource_provider_connection: Optional[Union[str, "_models.ResourceProviderConnection"]] = rest_field(
        name="resourceProviderConnection", visibility=["read", "create", "update", "delete", "query"]
    )
    """The direction for the resource provider connection. Known values are: \"Inbound\" and
     \"Outbound\"."""
    private_link: Optional[Union[str, "_models.PrivateLink"]] = rest_field(
        name="privateLink", visibility=["read", "create", "update", "delete", "query"]
    )
    """Indicates whether or not private link is enabled. Known values are: \"Disabled\" and
     \"Enabled\"."""
    public_ip_tag: Optional["_models.IpTag"] = rest_field(
        name="publicIpTag", visibility=["read", "create", "update", "delete", "query"]
    )
    """Gets or sets the IP tag for the public IPs created along with the HDInsight Clusters."""

    @overload
    def __init__(
        self,
        *,
        outbound_dependencies_managed_type: Optional[Union[str, "_models.OutboundDependenciesManagedType"]] = None,
        resource_provider_connection: Optional[Union[str, "_models.ResourceProviderConnection"]] = None,
        private_link: Optional[Union[str, "_models.PrivateLink"]] = None,
        public_ip_tag: Optional["_models.IpTag"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Operation(_Model):
    """The HDInsight REST API operation.

    :ivar name: The operation name: {provider}/{resource}/{operation}.
    :vartype name: str
    :ivar display: The display of operation.
    :vartype display: ~azure.mgmt.hdinsight.models.OperationDisplay
    :ivar properties: The operation properties.
    :vartype properties: ~azure.mgmt.hdinsight.models.OperationProperties
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The operation name: {provider}/{resource}/{operation}."""
    display: Optional["_models.OperationDisplay"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The display of operation."""
    properties: Optional["_models.OperationProperties"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The operation properties."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display: Optional["_models.OperationDisplay"] = None,
        properties: Optional["_models.OperationProperties"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class OperationDisplay(_Model):
    """The object that represents the operation.

    :ivar provider: The service provider: Microsoft.HDInsight.
    :vartype provider: str
    :ivar resource: The resource on which the operation is performed: Cluster, Applications, etc.
    :vartype resource: str
    :ivar operation: The operation type: read, write, delete, etc.
    :vartype operation: str
    :ivar description: Localized friendly description for the operation.
    :vartype description: str
    """

    provider: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The service provider: Microsoft.HDInsight."""
    resource: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The resource on which the operation is performed: Cluster, Applications, etc."""
    operation: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The operation type: read, write, delete, etc."""
    description: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """Localized friendly description for the operation."""

    @overload
    def __init__(
        self,
        *,
        provider: Optional[str] = None,
        resource: Optional[str] = None,
        operation: Optional[str] = None,
        description: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class OperationProperties(_Model):
    """The details of operation.

    :ivar service_specification: The specification of the service.
    :vartype service_specification: ~azure.mgmt.hdinsight.models.ServiceSpecification
    """

    service_specification: Optional["_models.ServiceSpecification"] = rest_field(
        name="serviceSpecification", visibility=["read", "create", "update", "delete", "query"]
    )
    """The specification of the service."""

    @overload
    def __init__(
        self,
        *,
        service_specification: Optional["_models.ServiceSpecification"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class OsProfile(_Model):
    """The Linux operation systems profile.

    :ivar linux_operating_system_profile: The Linux OS profile.
    :vartype linux_operating_system_profile:
     ~azure.mgmt.hdinsight.models.LinuxOperatingSystemProfile
    """

    linux_operating_system_profile: Optional["_models.LinuxOperatingSystemProfile"] = rest_field(
        name="linuxOperatingSystemProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The Linux OS profile."""

    @overload
    def __init__(
        self,
        *,
        linux_operating_system_profile: Optional["_models.LinuxOperatingSystemProfile"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class PrivateEndpoint(_Model):
    """The private endpoint.

    :ivar id: The private endpoint id.
    :vartype id: str
    """

    id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The private endpoint id."""

    @overload
    def __init__(
        self,
        *,
        id: Optional[str] = None,  # pylint: disable=redefined-builtin
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class PrivateEndpointConnection(ProxyResource):
    """The private endpoint connection.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    :ivar properties: The private endpoint connection properties. Required.
    :vartype properties: ~azure.mgmt.hdinsight.models.PrivateEndpointConnectionProperties
    """

    properties: "_models.PrivateEndpointConnectionProperties" = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The private endpoint connection properties. Required."""

    __flattened_items = [
        "private_endpoint",
        "private_link_service_connection_state",
        "link_identifier",
        "provisioning_state",
    ]

    @overload
    def __init__(
        self,
        *,
        properties: "_models.PrivateEndpointConnectionProperties",
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}
        super().__init__(*args, **kwargs)
        for k, v in _flattened_input.items():
            setattr(self, k, v)

    def __getattr__(self, name: str) -> Any:
        if name in self.__flattened_items:
            if self.properties is None:
                return None
            return getattr(self.properties, name)
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

    def __setattr__(self, key: str, value: Any) -> None:
        if key in self.__flattened_items:
            if self.properties is None:
                self.properties = self._attr_to_rest_field["properties"]._class_type()
            setattr(self.properties, key, value)
        else:
            super().__setattr__(key, value)


class PrivateEndpointConnectionProperties(_Model):
    """The private endpoint connection properties.

    :ivar private_endpoint: The private endpoint of the private endpoint connection.
    :vartype private_endpoint: ~azure.mgmt.hdinsight.models.PrivateEndpoint
    :ivar private_link_service_connection_state: The private link service connection state.
     Required.
    :vartype private_link_service_connection_state:
     ~azure.mgmt.hdinsight.models.PrivateLinkServiceConnectionState
    :ivar link_identifier: The link identifier.
    :vartype link_identifier: str
    :ivar provisioning_state: The provisioning state, which only appears in the response. Known
     values are: "InProgress", "Updating", "Failed", "Succeeded", "Canceled", and "Deleting".
    :vartype provisioning_state: str or
     ~azure.mgmt.hdinsight.models.PrivateEndpointConnectionProvisioningState
    """

    private_endpoint: Optional["_models.PrivateEndpoint"] = rest_field(name="privateEndpoint", visibility=["read"])
    """The private endpoint of the private endpoint connection."""
    private_link_service_connection_state: "_models.PrivateLinkServiceConnectionState" = rest_field(
        name="privateLinkServiceConnectionState", visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link service connection state. Required."""
    link_identifier: Optional[str] = rest_field(name="linkIdentifier", visibility=["read"])
    """The link identifier."""
    provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = rest_field(
        name="provisioningState", visibility=["read"]
    )
    """The provisioning state, which only appears in the response. Known values are: \"InProgress\",
     \"Updating\", \"Failed\", \"Succeeded\", \"Canceled\", and \"Deleting\"."""

    @overload
    def __init__(
        self,
        *,
        private_link_service_connection_state: "_models.PrivateLinkServiceConnectionState",
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class PrivateLinkConfiguration(_Model):
    """The private link configuration.

    :ivar id: The private link configuration id.
    :vartype id: str
    :ivar name: The name of private link configuration. Required.
    :vartype name: str
    :ivar type: The type of the private link configuration.
    :vartype type: str
    :ivar properties: The private link configuration properties. Required.
    :vartype properties: ~azure.mgmt.hdinsight.models.PrivateLinkConfigurationProperties
    """

    id: Optional[str] = rest_field(visibility=["read"])
    """The private link configuration id."""
    name: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of private link configuration. Required."""
    type: Optional[str] = rest_field(visibility=["read"])
    """The type of the private link configuration."""
    properties: "_models.PrivateLinkConfigurationProperties" = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link configuration properties. Required."""

    __flattened_items = ["group_id", "provisioning_state", "ip_configurations"]

    @overload
    def __init__(
        self,
        *,
        name: str,
        properties: "_models.PrivateLinkConfigurationProperties",
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}
        super().__init__(*args, **kwargs)
        for k, v in _flattened_input.items():
            setattr(self, k, v)

    def __getattr__(self, name: str) -> Any:
        if name in self.__flattened_items:
            if self.properties is None:
                return None
            return getattr(self.properties, name)
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

    def __setattr__(self, key: str, value: Any) -> None:
        if key in self.__flattened_items:
            if self.properties is None:
                self.properties = self._attr_to_rest_field["properties"]._class_type()
            setattr(self.properties, key, value)
        else:
            super().__setattr__(key, value)


class PrivateLinkConfigurationProperties(_Model):
    """The private link configuration properties.

    :ivar group_id: The HDInsight private linkable sub-resource name to apply the private link
     configuration to. For example, 'headnode', 'gateway', 'edgenode'. Required.
    :vartype group_id: str
    :ivar provisioning_state: The private link configuration provisioning state, which only appears
     in the response. Known values are: "InProgress", "Failed", "Succeeded", "Canceled", and
     "Deleting".
    :vartype provisioning_state: str or
     ~azure.mgmt.hdinsight.models.PrivateLinkConfigurationProvisioningState
    :ivar ip_configurations: The IP configurations for the private link service. Required.
    :vartype ip_configurations: list[~azure.mgmt.hdinsight.models.IPConfiguration]
    """

    group_id: str = rest_field(name="groupId", visibility=["read", "create", "update", "delete", "query"])
    """The HDInsight private linkable sub-resource name to apply the private link configuration to.
     For example, 'headnode', 'gateway', 'edgenode'. Required."""
    provisioning_state: Optional[Union[str, "_models.PrivateLinkConfigurationProvisioningState"]] = rest_field(
        name="provisioningState", visibility=["read"]
    )
    """The private link configuration provisioning state, which only appears in the response. Known
     values are: \"InProgress\", \"Failed\", \"Succeeded\", \"Canceled\", and \"Deleting\"."""
    ip_configurations: list["_models.IPConfiguration"] = rest_field(
        name="ipConfigurations", visibility=["read", "create", "update", "delete", "query"]
    )
    """The IP configurations for the private link service. Required."""

    @overload
    def __init__(
        self,
        *,
        group_id: str,
        ip_configurations: list["_models.IPConfiguration"],
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class PrivateLinkResource(ProxyResource):
    """A private link resource.

    :ivar id: Fully qualified resource ID for the resource. Ex -
     /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
    :vartype id: str
    :ivar name: The name of the resource.
    :vartype name: str
    :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
     "Microsoft.Storage/storageAccounts".
    :vartype type: str
    :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
     information.
    :vartype system_data: ~azure.mgmt.hdinsight.models.SystemData
    :ivar properties: Resource properties.
    :vartype properties: ~azure.mgmt.hdinsight.models.PrivateLinkResourceProperties
    """

    properties: Optional["_models.PrivateLinkResourceProperties"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """Resource properties."""

    __flattened_items = ["group_id", "required_members", "required_zone_names"]

    @overload
    def __init__(
        self,
        *,
        properties: Optional["_models.PrivateLinkResourceProperties"] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}
        super().__init__(*args, **kwargs)
        for k, v in _flattened_input.items():
            setattr(self, k, v)

    def __getattr__(self, name: str) -> Any:
        if name in self.__flattened_items:
            if self.properties is None:
                return None
            return getattr(self.properties, name)
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

    def __setattr__(self, key: str, value: Any) -> None:
        if key in self.__flattened_items:
            if self.properties is None:
                self.properties = self._attr_to_rest_field["properties"]._class_type()
            setattr(self.properties, key, value)
        else:
            super().__setattr__(key, value)


class PrivateLinkResourceListResult(_Model):
    """A list of private link resources.

    :ivar value: Array of private link resources.
    :vartype value: list[~azure.mgmt.hdinsight.models.PrivateLinkResource]
    """

    value: Optional[list["_models.PrivateLinkResource"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """Array of private link resources."""

    @overload
    def __init__(
        self,
        *,
        value: Optional[list["_models.PrivateLinkResource"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class PrivateLinkResourceProperties(_Model):
    """Properties of a private link resource.

    :ivar group_id: The private link resource group id.
    :vartype group_id: str
    :ivar required_members: The private link resource required member names.
    :vartype required_members: list[str]
    :ivar required_zone_names: The private link resource private link DNS zone name.
    :vartype required_zone_names: list[str]
    """

    group_id: Optional[str] = rest_field(name="groupId", visibility=["read"])
    """The private link resource group id."""
    required_members: Optional[list[str]] = rest_field(name="requiredMembers", visibility=["read"])
    """The private link resource required member names."""
    required_zone_names: Optional[list[str]] = rest_field(
        name="requiredZoneNames", visibility=["read", "create", "update", "delete", "query"]
    )
    """The private link resource private link DNS zone name."""

    @overload
    def __init__(
        self,
        *,
        required_zone_names: Optional[list[str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class PrivateLinkServiceConnectionState(_Model):
    """The private link service connection state.

    :ivar status: The concrete private link service connection. Required. Known values are:
     "Approved", "Rejected", "Pending", and "Removed".
    :vartype status: str or ~azure.mgmt.hdinsight.models.PrivateLinkServiceConnectionStatus
    :ivar description: The optional description of the status.
    :vartype description: str
    :ivar actions_required: Whether there is further actions.
    :vartype actions_required: str
    """

    status: Union[str, "_models.PrivateLinkServiceConnectionStatus"] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The concrete private link service connection. Required. Known values are: \"Approved\",
     \"Rejected\", \"Pending\", and \"Removed\"."""
    description: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The optional description of the status."""
    actions_required: Optional[str] = rest_field(
        name="actionsRequired", visibility=["read", "create", "update", "delete", "query"]
    )
    """Whether there is further actions."""

    @overload
    def __init__(
        self,
        *,
        status: Union[str, "_models.PrivateLinkServiceConnectionStatus"],
        description: Optional[str] = None,
        actions_required: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class QuotaCapability(_Model):
    """The regional quota capability.

    :ivar cores_used: The number of cores used in the subscription.
    :vartype cores_used: int
    :ivar max_cores_allowed: The number of cores that the subscription allowed.
    :vartype max_cores_allowed: int
    :ivar regional_quotas: The list of region quota capabilities.
    :vartype regional_quotas: list[~azure.mgmt.hdinsight.models.RegionalQuotaCapability]
    """

    cores_used: Optional[int] = rest_field(name="coresUsed", visibility=["read", "create", "update", "delete", "query"])
    """The number of cores used in the subscription."""
    max_cores_allowed: Optional[int] = rest_field(
        name="maxCoresAllowed", visibility=["read", "create", "update", "delete", "query"]
    )
    """The number of cores that the subscription allowed."""
    regional_quotas: Optional[list["_models.RegionalQuotaCapability"]] = rest_field(
        name="regionalQuotas", visibility=["read"]
    )
    """The list of region quota capabilities."""

    @overload
    def __init__(
        self,
        *,
        cores_used: Optional[int] = None,
        max_cores_allowed: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class QuotaInfo(_Model):
    """The quota properties for the cluster.

    :ivar cores_used: The cores used by the cluster.
    :vartype cores_used: int
    """

    cores_used: Optional[int] = rest_field(name="coresUsed", visibility=["read", "create", "update", "delete", "query"])
    """The cores used by the cluster."""

    @overload
    def __init__(
        self,
        *,
        cores_used: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class RegionalQuotaCapability(_Model):
    """The regional quota capacity.

    :ivar region_name: The region name.
    :vartype region_name: str
    :ivar cores_used: The number of cores used in the region.
    :vartype cores_used: int
    :ivar cores_available: The number of cores available in the region.
    :vartype cores_available: int
    """

    region_name: Optional[str] = rest_field(
        name="regionName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The region name."""
    cores_used: Optional[int] = rest_field(name="coresUsed", visibility=["read", "create", "update", "delete", "query"])
    """The number of cores used in the region."""
    cores_available: Optional[int] = rest_field(
        name="coresAvailable", visibility=["read", "create", "update", "delete", "query"]
    )
    """The number of cores available in the region."""

    @overload
    def __init__(
        self,
        *,
        region_name: Optional[str] = None,
        cores_used: Optional[int] = None,
        cores_available: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class RegionsCapability(_Model):
    """The regions capability.

    :ivar available: The list of region capabilities.
    :vartype available: list[str]
    """

    available: Optional[list[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The list of region capabilities."""

    @overload
    def __init__(
        self,
        *,
        available: Optional[list[str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ResourceId(_Model):
    """The azure resource id.

    :ivar id: The azure resource id.
    :vartype id: str
    """

    id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The azure resource id."""

    @overload
    def __init__(
        self,
        *,
        id: Optional[str] = None,  # pylint: disable=redefined-builtin
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Role(_Model):
    """Describes a role on the cluster.

    :ivar name: The name of the role.
    :vartype name: str
    :ivar min_instance_count: The minimum instance count of the cluster.
    :vartype min_instance_count: int
    :ivar target_instance_count: The instance count of the cluster.
    :vartype target_instance_count: int
    :ivar vm_group_name: The name of the virtual machine group.
    :vartype vm_group_name: str
    :ivar autoscale_configuration: The autoscale configurations.
    :vartype autoscale_configuration: ~azure.mgmt.hdinsight.models.Autoscale
    :ivar hardware_profile: The hardware profile.
    :vartype hardware_profile: ~azure.mgmt.hdinsight.models.HardwareProfile
    :ivar os_profile: The operating system profile.
    :vartype os_profile: ~azure.mgmt.hdinsight.models.OsProfile
    :ivar virtual_network_profile: The virtual network profile.
    :vartype virtual_network_profile: ~azure.mgmt.hdinsight.models.VirtualNetworkProfile
    :ivar data_disks_groups: The data disks groups for the role.
    :vartype data_disks_groups: list[~azure.mgmt.hdinsight.models.DataDisksGroups]
    :ivar script_actions: The list of script actions on the role.
    :vartype script_actions: list[~azure.mgmt.hdinsight.models.ScriptAction]
    :ivar encrypt_data_disks: Indicates whether encrypt the data disks.
    :vartype encrypt_data_disks: bool
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the role."""
    min_instance_count: Optional[int] = rest_field(
        name="minInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The minimum instance count of the cluster."""
    target_instance_count: Optional[int] = rest_field(
        name="targetInstanceCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The instance count of the cluster."""
    vm_group_name: Optional[str] = rest_field(name="VMGroupName", visibility=["read", "create"])
    """The name of the virtual machine group."""
    autoscale_configuration: Optional["_models.Autoscale"] = rest_field(
        name="autoscale", visibility=["read", "create", "update", "delete", "query"]
    )
    """The autoscale configurations."""
    hardware_profile: Optional["_models.HardwareProfile"] = rest_field(
        name="hardwareProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The hardware profile."""
    os_profile: Optional["_models.OsProfile"] = rest_field(
        name="osProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The operating system profile."""
    virtual_network_profile: Optional["_models.VirtualNetworkProfile"] = rest_field(
        name="virtualNetworkProfile", visibility=["read", "create", "update", "delete", "query"]
    )
    """The virtual network profile."""
    data_disks_groups: Optional[list["_models.DataDisksGroups"]] = rest_field(
        name="dataDisksGroups", visibility=["read", "create", "update", "delete", "query"]
    )
    """The data disks groups for the role."""
    script_actions: Optional[list["_models.ScriptAction"]] = rest_field(
        name="scriptActions", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of script actions on the role."""
    encrypt_data_disks: Optional[bool] = rest_field(
        name="encryptDataDisks", visibility=["read", "create", "update", "delete", "query"]
    )
    """Indicates whether encrypt the data disks."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        min_instance_count: Optional[int] = None,
        target_instance_count: Optional[int] = None,
        vm_group_name: Optional[str] = None,
        autoscale_configuration: Optional["_models.Autoscale"] = None,
        hardware_profile: Optional["_models.HardwareProfile"] = None,
        os_profile: Optional["_models.OsProfile"] = None,
        virtual_network_profile: Optional["_models.VirtualNetworkProfile"] = None,
        data_disks_groups: Optional[list["_models.DataDisksGroups"]] = None,
        script_actions: Optional[list["_models.ScriptAction"]] = None,
        encrypt_data_disks: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class RuntimeScriptAction(_Model):
    """Describes a script action on a running cluster.

    :ivar name: The name of the script action. Required.
    :vartype name: str
    :ivar uri: The URI to the script. Required.
    :vartype uri: str
    :ivar parameters: The parameters for the script.
    :vartype parameters: str
    :ivar roles: The list of roles where script will be executed. Required.
    :vartype roles: list[str]
    :ivar application_name: The application name of the script action, if any.
    :vartype application_name: str
    """

    name: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the script action. Required."""
    uri: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The URI to the script. Required."""
    parameters: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The parameters for the script."""
    roles: list[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The list of roles where script will be executed. Required."""
    application_name: Optional[str] = rest_field(name="applicationName", visibility=["read"])
    """The application name of the script action, if any."""

    @overload
    def __init__(
        self,
        *,
        name: str,
        uri: str,
        roles: list[str],
        parameters: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class RuntimeScriptActionDetail(RuntimeScriptAction):
    """The execution details of a script action.

    :ivar name: The name of the script action. Required.
    :vartype name: str
    :ivar uri: The URI to the script. Required.
    :vartype uri: str
    :ivar parameters: The parameters for the script.
    :vartype parameters: str
    :ivar roles: The list of roles where script will be executed. Required.
    :vartype roles: list[str]
    :ivar application_name: The application name of the script action, if any.
    :vartype application_name: str
    :ivar script_execution_id: The execution id of the script action.
    :vartype script_execution_id: int
    :ivar start_time: The start time of script action execution.
    :vartype start_time: str
    :ivar end_time: The end time of script action execution.
    :vartype end_time: str
    :ivar status: The current execution status of the script action.
    :vartype status: str
    :ivar operation: The reason why the script action was executed.
    :vartype operation: str
    :ivar execution_summary: The summary of script action execution result.
    :vartype execution_summary: list[~azure.mgmt.hdinsight.models.ScriptActionExecutionSummary]
    :ivar debug_information: The script action execution debug information.
    :vartype debug_information: str
    """

    script_execution_id: Optional[int] = rest_field(name="scriptExecutionId", visibility=["read"])
    """The execution id of the script action."""
    start_time: Optional[str] = rest_field(name="startTime", visibility=["read"])
    """The start time of script action execution."""
    end_time: Optional[str] = rest_field(name="endTime", visibility=["read"])
    """The end time of script action execution."""
    status: Optional[str] = rest_field(visibility=["read"])
    """The current execution status of the script action."""
    operation: Optional[str] = rest_field(visibility=["read"])
    """The reason why the script action was executed."""
    execution_summary: Optional[list["_models.ScriptActionExecutionSummary"]] = rest_field(
        name="executionSummary", visibility=["read"]
    )
    """The summary of script action execution result."""
    debug_information: Optional[str] = rest_field(name="debugInformation", visibility=["read"])
    """The script action execution debug information."""

    @overload
    def __init__(
        self,
        *,
        name: str,
        uri: str,
        roles: list[str],
        parameters: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ScriptAction(_Model):
    """Describes a script action on role on the cluster.

    :ivar name: The name of the script action. Required.
    :vartype name: str
    :ivar uri: The URI to the script. Required.
    :vartype uri: str
    :ivar parameters: The parameters for the script provided. Required.
    :vartype parameters: str
    """

    name: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the script action. Required."""
    uri: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The URI to the script. Required."""
    parameters: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The parameters for the script provided. Required."""

    @overload
    def __init__(
        self,
        *,
        name: str,
        uri: str,
        parameters: str,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ScriptActionExecutionSummary(_Model):
    """The execution summary of a script action.

    :ivar status: The status of script action execution.
    :vartype status: str
    :ivar instance_count: The instance count for a given script action execution status.
    :vartype instance_count: int
    """

    status: Optional[str] = rest_field(visibility=["read"])
    """The status of script action execution."""
    instance_count: Optional[int] = rest_field(name="instanceCount", visibility=["read"])
    """The instance count for a given script action execution status."""


class SecurityProfile(_Model):
    """The security profile which contains Ssh public key for the HDInsight cluster.

    :ivar directory_type: The directory type. "ActiveDirectory"
    :vartype directory_type: str or ~azure.mgmt.hdinsight.models.DirectoryType
    :ivar domain: The organization's active directory domain.
    :vartype domain: str
    :ivar organizational_unit_dn: The organizational unit within the Active Directory to place the
     cluster and service accounts.
    :vartype organizational_unit_dn: str
    :ivar ldaps_urls: The LDAPS protocol URLs to communicate with the Active Directory.
    :vartype ldaps_urls: list[str]
    :ivar domain_username: The domain user account that will have admin privileges on the cluster.
    :vartype domain_username: str
    :ivar domain_user_password: The domain admin password.
    :vartype domain_user_password: str
    :ivar cluster_users_group_d_ns: Optional. The Distinguished Names for cluster user groups.
    :vartype cluster_users_group_d_ns: list[str]
    :ivar aadds_resource_id: The resource ID of the user's Azure Active Directory Domain Service.
    :vartype aadds_resource_id: str
    :ivar msi_resource_id: User assigned identity that has permissions to read and create
     cluster-related artifacts in the user's AADDS.
    :vartype msi_resource_id: str
    """

    directory_type: Optional[Union[str, "_models.DirectoryType"]] = rest_field(
        name="directoryType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The directory type. \"ActiveDirectory\""""
    domain: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The organization's active directory domain."""
    organizational_unit_dn: Optional[str] = rest_field(name="organizationalUnitDN", visibility=["read", "create"])
    """The organizational unit within the Active Directory to place the cluster and service accounts."""
    ldaps_urls: Optional[list[str]] = rest_field(
        name="ldapsUrls", visibility=["read", "create", "update", "delete", "query"]
    )
    """The LDAPS protocol URLs to communicate with the Active Directory."""
    domain_username: Optional[str] = rest_field(
        name="domainUsername", visibility=["read", "create", "update", "delete", "query"]
    )
    """The domain user account that will have admin privileges on the cluster."""
    domain_user_password: Optional[str] = rest_field(
        name="domainUserPassword", visibility=["read", "create", "update", "delete", "query"]
    )
    """The domain admin password."""
    cluster_users_group_d_ns: Optional[list[str]] = rest_field(
        name="clusterUsersGroupDNs", visibility=["read", "create", "update", "delete", "query"]
    )
    """Optional. The Distinguished Names for cluster user groups."""
    aadds_resource_id: Optional[str] = rest_field(
        name="aaddsResourceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The resource ID of the user's Azure Active Directory Domain Service."""
    msi_resource_id: Optional[str] = rest_field(
        name="msiResourceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """User assigned identity that has permissions to read and create cluster-related artifacts in the
     user's AADDS."""

    @overload
    def __init__(
        self,
        *,
        directory_type: Optional[Union[str, "_models.DirectoryType"]] = None,
        domain: Optional[str] = None,
        organizational_unit_dn: Optional[str] = None,
        ldaps_urls: Optional[list[str]] = None,
        domain_username: Optional[str] = None,
        domain_user_password: Optional[str] = None,
        cluster_users_group_d_ns: Optional[list[str]] = None,
        aadds_resource_id: Optional[str] = None,
        msi_resource_id: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ServiceSpecification(_Model):
    """The specification of the service.

    :ivar metric_specifications: The metric specifications.
    :vartype metric_specifications: list[~azure.mgmt.hdinsight.models.MetricSpecifications]
    """

    metric_specifications: Optional[list["_models.MetricSpecifications"]] = rest_field(
        name="metricSpecifications", visibility=["read", "create", "update", "delete", "query"]
    )
    """The metric specifications."""

    @overload
    def __init__(
        self,
        *,
        metric_specifications: Optional[list["_models.MetricSpecifications"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class SshProfile(_Model):
    """The list of SSH public keys.

    :ivar public_keys: The list of SSH public keys.
    :vartype public_keys: list[~azure.mgmt.hdinsight.models.SshPublicKey]
    """

    public_keys: Optional[list["_models.SshPublicKey"]] = rest_field(
        name="publicKeys", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of SSH public keys."""

    @overload
    def __init__(
        self,
        *,
        public_keys: Optional[list["_models.SshPublicKey"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class SshPublicKey(_Model):
    """The SSH public key for the cluster nodes.

    :ivar certificate_data: The certificate for SSH.
    :vartype certificate_data: str
    """

    certificate_data: Optional[str] = rest_field(
        name="certificateData", visibility=["read", "create", "update", "delete", "query"]
    )
    """The certificate for SSH."""

    @overload
    def __init__(
        self,
        *,
        certificate_data: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class StorageAccount(_Model):
    """The storage Account.

    :ivar name: The name of the storage account.
    :vartype name: str
    :ivar is_default: Whether or not the storage account is the default storage account.
    :vartype is_default: bool
    :ivar container: The container in the storage account, only to be specified for WASB storage
     accounts.
    :vartype container: str
    :ivar file_system: The filesystem, only to be specified for Azure Data Lake Storage Gen 2.
    :vartype file_system: str
    :ivar key: The storage account access key.
    :vartype key: str
    :ivar resource_id: The resource ID of storage account, only to be specified for Azure Data Lake
     Storage Gen 2.
    :vartype resource_id: str
    :ivar msi_resource_id: The managed identity (MSI) that is allowed to access the storage
     account, only to be specified for Azure Data Lake Storage Gen 2.
    :vartype msi_resource_id: str
    :ivar saskey: The shared access signature key.
    :vartype saskey: str
    :ivar fileshare: The file share name.
    :vartype fileshare: str
    :ivar enable_secure_channel: Enable secure channel or not, it's an optional field. Default
     value is false when cluster version < 5.1 and true when cluster version >= 5.1 ,.
    :vartype enable_secure_channel: bool
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the storage account."""
    is_default: Optional[bool] = rest_field(
        name="isDefault", visibility=["read", "create", "update", "delete", "query"]
    )
    """Whether or not the storage account is the default storage account."""
    container: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The container in the storage account, only to be specified for WASB storage accounts."""
    file_system: Optional[str] = rest_field(
        name="fileSystem", visibility=["read", "create", "update", "delete", "query"]
    )
    """The filesystem, only to be specified for Azure Data Lake Storage Gen 2."""
    key: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The storage account access key."""
    resource_id: Optional[str] = rest_field(
        name="resourceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The resource ID of storage account, only to be specified for Azure Data Lake Storage Gen 2."""
    msi_resource_id: Optional[str] = rest_field(
        name="msiResourceId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The managed identity (MSI) that is allowed to access the storage account, only to be specified
     for Azure Data Lake Storage Gen 2."""
    saskey: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The shared access signature key."""
    fileshare: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The file share name."""
    enable_secure_channel: Optional[bool] = rest_field(
        name="enableSecureChannel", visibility=["read", "create", "update", "delete", "query"]
    )
    """Enable secure channel or not, it's an optional field. Default value is false when cluster
     version < 5.1 and true when cluster version >= 5.1 ,."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        is_default: Optional[bool] = None,
        container: Optional[str] = None,
        file_system: Optional[str] = None,
        key: Optional[str] = None,
        resource_id: Optional[str] = None,
        msi_resource_id: Optional[str] = None,
        saskey: Optional[str] = None,
        fileshare: Optional[str] = None,
        enable_secure_channel: Optional[bool] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class StorageProfile(_Model):
    """The storage profile.

    :ivar storageaccounts: The list of storage accounts in the cluster.
    :vartype storageaccounts: list[~azure.mgmt.hdinsight.models.StorageAccount]
    """

    storageaccounts: Optional[list["_models.StorageAccount"]] = rest_field(
        visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of storage accounts in the cluster."""

    @overload
    def __init__(
        self,
        *,
        storageaccounts: Optional[list["_models.StorageAccount"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class SystemData(_Model):
    """Metadata pertaining to creation and last modification of the resource.

    :ivar created_by: The identity that created the resource.
    :vartype created_by: str
    :ivar created_by_type: The type of identity that created the resource. Known values are:
     "User", "Application", "ManagedIdentity", and "Key".
    :vartype created_by_type: str or ~azure.mgmt.hdinsight.models.CreatedByType
    :ivar created_at: The timestamp of resource creation (UTC).
    :vartype created_at: ~datetime.datetime
    :ivar last_modified_by: The identity that last modified the resource.
    :vartype last_modified_by: str
    :ivar last_modified_by_type: The type of identity that last modified the resource. Known values
     are: "User", "Application", "ManagedIdentity", and "Key".
    :vartype last_modified_by_type: str or ~azure.mgmt.hdinsight.models.CreatedByType
    :ivar last_modified_at: The timestamp of resource last modification (UTC).
    :vartype last_modified_at: ~datetime.datetime
    """

    created_by: Optional[str] = rest_field(name="createdBy", visibility=["read", "create", "update", "delete", "query"])
    """The identity that created the resource."""
    created_by_type: Optional[Union[str, "_models.CreatedByType"]] = rest_field(
        name="createdByType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The type of identity that created the resource. Known values are: \"User\", \"Application\",
     \"ManagedIdentity\", and \"Key\"."""
    created_at: Optional[datetime.datetime] = rest_field(
        name="createdAt", visibility=["read", "create", "update", "delete", "query"], format="rfc3339"
    )
    """The timestamp of resource creation (UTC)."""
    last_modified_by: Optional[str] = rest_field(
        name="lastModifiedBy", visibility=["read", "create", "update", "delete", "query"]
    )
    """The identity that last modified the resource."""
    last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = rest_field(
        name="lastModifiedByType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The type of identity that last modified the resource. Known values are: \"User\",
     \"Application\", \"ManagedIdentity\", and \"Key\"."""
    last_modified_at: Optional[datetime.datetime] = rest_field(
        name="lastModifiedAt", visibility=["read", "create", "update", "delete", "query"], format="rfc3339"
    )
    """The timestamp of resource last modification (UTC)."""

    @overload
    def __init__(
        self,
        *,
        created_by: Optional[str] = None,
        created_by_type: Optional[Union[str, "_models.CreatedByType"]] = None,
        created_at: Optional[datetime.datetime] = None,
        last_modified_by: Optional[str] = None,
        last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = None,
        last_modified_at: Optional[datetime.datetime] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class UpdateClusterIdentityCertificateParameters(_Model):  # pylint: disable=name-too-long
    """The update cluster identity certificate request parameters.

    :ivar application_id: The application id.
    :vartype application_id: str
    :ivar certificate: The certificate in base64 encoded format.
    :vartype certificate: str
    :ivar certificate_password: The password of the certificate.
    :vartype certificate_password: str
    """

    application_id: Optional[str] = rest_field(
        name="applicationId", visibility=["read", "create", "update", "delete", "query"]
    )
    """The application id."""
    certificate: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The certificate in base64 encoded format."""
    certificate_password: Optional[str] = rest_field(
        name="certificatePassword", visibility=["read", "create", "update", "delete", "query"]
    )
    """The password of the certificate."""

    @overload
    def __init__(
        self,
        *,
        application_id: Optional[str] = None,
        certificate: Optional[str] = None,
        certificate_password: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class UpdateGatewaySettingsParameters(_Model):
    """The update gateway settings request parameters. Note either basic or entra user should be
    provided at a time.

    :ivar is_credential_enabled: Indicates whether or not the gateway settings based authorization
     is enabled.
    :vartype is_credential_enabled: bool
    :ivar user_name: The gateway settings user name.
    :vartype user_name: str
    :ivar password: The gateway settings user password.
    :vartype password: str
    :ivar rest_auth_entra_users: List of Entra users for gateway access.
    :vartype rest_auth_entra_users: list[~azure.mgmt.hdinsight.models.EntraUserInfo]
    """

    is_credential_enabled: Optional[bool] = rest_field(
        name="restAuthCredential.isEnabled", visibility=["read", "create", "update", "delete", "query"]
    )
    """Indicates whether or not the gateway settings based authorization is enabled."""
    user_name: Optional[str] = rest_field(
        name="restAuthCredential.username", visibility=["read", "create", "update", "delete", "query"]
    )
    """The gateway settings user name."""
    password: Optional[str] = rest_field(
        name="restAuthCredential.password", visibility=["read", "create", "update", "delete", "query"]
    )
    """The gateway settings user password."""
    rest_auth_entra_users: Optional[list["_models.EntraUserInfo"]] = rest_field(
        name="restAuthEntraUsers", visibility=["read", "create", "update", "delete", "query"]
    )
    """List of Entra users for gateway access."""

    @overload
    def __init__(
        self,
        *,
        is_credential_enabled: Optional[bool] = None,
        user_name: Optional[str] = None,
        password: Optional[str] = None,
        rest_auth_entra_users: Optional[list["_models.EntraUserInfo"]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class Usage(_Model):
    """The details about the usage of a particular limited resource.

    :ivar unit: The type of measurement for usage.
    :vartype unit: str
    :ivar current_value: The current usage.
    :vartype current_value: int
    :ivar limit: The maximum allowed usage.
    :vartype limit: int
    :ivar name: The details about the localizable name of the used resource.
    :vartype name: ~azure.mgmt.hdinsight.models.LocalizedName
    """

    unit: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The type of measurement for usage."""
    current_value: Optional[int] = rest_field(
        name="currentValue", visibility=["read", "create", "update", "delete", "query"]
    )
    """The current usage."""
    limit: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The maximum allowed usage."""
    name: Optional["_models.LocalizedName"] = rest_field(visibility=["read"])
    """The details about the localizable name of the used resource."""

    @overload
    def __init__(
        self,
        *,
        unit: Optional[str] = None,
        current_value: Optional[int] = None,
        limit: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class UsagesListResult(_Model):
    """The response for the operation to get regional usages for a subscription.

    :ivar value: The list of usages.
    :vartype value: list[~azure.mgmt.hdinsight.models.Usage]
    """

    value: Optional[list["_models.Usage"]] = rest_field(visibility=["read"])
    """The list of usages."""


class UserAssignedIdentity(_Model):
    """The User Assigned Identity.

    :ivar principal_id: The principal id of user assigned identity.
    :vartype principal_id: str
    :ivar client_id: The client id of user assigned identity.
    :vartype client_id: str
    :ivar tenant_id: The tenant id of user assigned identity.
    :vartype tenant_id: str
    """

    principal_id: Optional[str] = rest_field(name="principalId", visibility=["read"])
    """The principal id of user assigned identity."""
    client_id: Optional[str] = rest_field(name="clientId", visibility=["read"])
    """The client id of user assigned identity."""
    tenant_id: Optional[str] = rest_field(name="tenantId", visibility=["read", "create", "update", "delete", "query"])
    """The tenant id of user assigned identity."""

    @overload
    def __init__(
        self,
        *,
        tenant_id: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ValidationErrorInfo(_Model):
    """The validation error information.

    :ivar code: The error code.
    :vartype code: str
    :ivar message: The error message.
    :vartype message: str
    :ivar error_resource: The error resource.
    :vartype error_resource: str
    :ivar message_arguments: The message arguments.
    :vartype message_arguments: list[str]
    """

    code: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The error code."""
    message: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The error message."""
    error_resource: Optional[str] = rest_field(
        name="errorResource", visibility=["read", "create", "update", "delete", "query"]
    )
    """The error resource."""
    message_arguments: Optional[list[str]] = rest_field(
        name="messageArguments", visibility=["read", "create", "update", "delete", "query"]
    )
    """The message arguments."""

    @overload
    def __init__(
        self,
        *,
        code: Optional[str] = None,
        message: Optional[str] = None,
        error_resource: Optional[str] = None,
        message_arguments: Optional[list[str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class VersionsCapability(_Model):
    """The version capability.

    :ivar available: The list of version capabilities.
    :vartype available: list[~azure.mgmt.hdinsight.models.VersionSpec]
    """

    available: Optional[list["_models.VersionSpec"]] = rest_field(visibility=["read"])
    """The list of version capabilities."""


class VersionSpec(_Model):
    """The version properties.

    :ivar friendly_name: The friendly name.
    :vartype friendly_name: str
    :ivar display_name: The display name.
    :vartype display_name: str
    :ivar is_default: Whether or not the version is the default version.
    :vartype is_default: bool
    :ivar component_versions: The component version property.
    :vartype component_versions: dict[str, str]
    """

    friendly_name: Optional[str] = rest_field(
        name="friendlyName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The friendly name."""
    display_name: Optional[str] = rest_field(
        name="displayName", visibility=["read", "create", "update", "delete", "query"]
    )
    """The display name."""
    is_default: Optional[bool] = rest_field(
        name="isDefault", visibility=["read", "create", "update", "delete", "query"]
    )
    """Whether or not the version is the default version."""
    component_versions: Optional[dict[str, str]] = rest_field(
        name="componentVersions", visibility=["read", "create", "update", "delete", "query"]
    )
    """The component version property."""

    @overload
    def __init__(
        self,
        *,
        friendly_name: Optional[str] = None,
        display_name: Optional[str] = None,
        is_default: Optional[bool] = None,
        component_versions: Optional[dict[str, str]] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class VirtualNetworkProfile(_Model):
    """The virtual network properties.

    :ivar id: The ID of the virtual network.
    :vartype id: str
    :ivar subnet: The name of the subnet.
    :vartype subnet: str
    """

    id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The ID of the virtual network."""
    subnet: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The name of the subnet."""

    @overload
    def __init__(
        self,
        *,
        id: Optional[str] = None,  # pylint: disable=redefined-builtin
        subnet: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class VmSizeCompatibilityFilterV2(_Model):
    """This class represent a single filter object that defines a multidimensional set. The dimensions
    of this set are Regions, ClusterFlavors, NodeTypes and ClusterVersions. The constraint should
    be defined based on the following: FilterMode (Exclude vs Include), VMSizes (the vm sizes in
    affect of exclusion/inclusion) and the ordering of the Filters. Later filters override previous
    settings if conflicted.

    :ivar filter_mode: The filtering mode. Effectively this can enabling or disabling the VM sizes
     in a particular set. Known values are: "Exclude", "Include", "Recommend", and "Default".
    :vartype filter_mode: str or ~azure.mgmt.hdinsight.models.FilterMode
    :ivar regions: The list of regions under the effect of the filter.
    :vartype regions: list[str]
    :ivar cluster_flavors: The list of cluster flavors under the effect of the filter.
    :vartype cluster_flavors: list[str]
    :ivar node_types: The list of node types affected by the filter.
    :vartype node_types: list[str]
    :ivar cluster_versions: The list of cluster versions affected in Major.Minor format.
    :vartype cluster_versions: list[str]
    :ivar os_type: The OSType affected, Windows or Linux.
    :vartype os_type: list[str or ~azure.mgmt.hdinsight.models.OSType]
    :ivar vm_sizes: The list of virtual machine sizes to include or exclude.
    :vartype vm_sizes: list[str]
    :ivar esp_applied: Whether apply for ESP cluster. 'true' means only for ESP, 'false' means only
     for non-ESP, null or empty string or others mean for both.
    :vartype esp_applied: str
    :ivar compute_isolation_supported: Whether support compute isolation. 'true' means only for
     ComputeIsolationEnabled, 'false' means only for regular cluster.
    :vartype compute_isolation_supported: str
    """

    filter_mode: Optional[Union[str, "_models.FilterMode"]] = rest_field(
        name="filterMode", visibility=["read", "create", "update", "delete", "query"]
    )
    """The filtering mode. Effectively this can enabling or disabling the VM sizes in a particular
     set. Known values are: \"Exclude\", \"Include\", \"Recommend\", and \"Default\"."""
    regions: Optional[list[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The list of regions under the effect of the filter."""
    cluster_flavors: Optional[list[str]] = rest_field(
        name="clusterFlavors", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of cluster flavors under the effect of the filter."""
    node_types: Optional[list[str]] = rest_field(
        name="nodeTypes", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of node types affected by the filter."""
    cluster_versions: Optional[list[str]] = rest_field(
        name="clusterVersions", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of cluster versions affected in Major.Minor format."""
    os_type: Optional[list[Union[str, "_models.OSType"]]] = rest_field(
        name="osType", visibility=["read", "create", "update", "delete", "query"]
    )
    """The OSType affected, Windows or Linux."""
    vm_sizes: Optional[list[str]] = rest_field(
        name="vmSizes", visibility=["read", "create", "update", "delete", "query"]
    )
    """The list of virtual machine sizes to include or exclude."""
    esp_applied: Optional[str] = rest_field(
        name="espApplied", visibility=["read", "create", "update", "delete", "query"]
    )
    """Whether apply for ESP cluster. 'true' means only for ESP, 'false' means only for non-ESP, null
     or empty string or others mean for both."""
    compute_isolation_supported: Optional[str] = rest_field(
        name="computeIsolationSupported", visibility=["read", "create", "update", "delete", "query"]
    )
    """Whether support compute isolation. 'true' means only for ComputeIsolationEnabled, 'false' means
     only for regular cluster."""

    @overload
    def __init__(
        self,
        *,
        filter_mode: Optional[Union[str, "_models.FilterMode"]] = None,
        regions: Optional[list[str]] = None,
        cluster_flavors: Optional[list[str]] = None,
        node_types: Optional[list[str]] = None,
        cluster_versions: Optional[list[str]] = None,
        os_type: Optional[list[Union[str, "_models.OSType"]]] = None,
        vm_sizes: Optional[list[str]] = None,
        esp_applied: Optional[str] = None,
        compute_isolation_supported: Optional[str] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class VmSizeProperty(_Model):
    """The vm size property.

    :ivar name: The vm size name.
    :vartype name: str
    :ivar cores: The number of cores that the vm size has.
    :vartype cores: int
    :ivar data_disk_storage_tier: The data disk storage tier of the vm size.
    :vartype data_disk_storage_tier: str
    :ivar label: The label of the vm size.
    :vartype label: str
    :ivar max_data_disk_count: The max data disk count of the vm size.
    :vartype max_data_disk_count: int
    :ivar memory_in_mb: The memory whose unit is MB of the vm size.
    :vartype memory_in_mb: int
    :ivar supported_by_virtual_machines: This indicates this vm size is supported by virtual
     machines or not.
    :vartype supported_by_virtual_machines: bool
    :ivar supported_by_web_worker_roles: The indicates this vm size is supported by web worker
     roles or not.
    :vartype supported_by_web_worker_roles: bool
    :ivar virtual_machine_resource_disk_size_in_mb: The virtual machine resource disk size whose
     unit is MB of the vm size.
    :vartype virtual_machine_resource_disk_size_in_mb: int
    :ivar web_worker_resource_disk_size_in_mb: The web worker resource disk size whose unit is MB
     of the vm size.
    :vartype web_worker_resource_disk_size_in_mb: int
    """

    name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The vm size name."""
    cores: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The number of cores that the vm size has."""
    data_disk_storage_tier: Optional[str] = rest_field(
        name="dataDiskStorageTier", visibility=["read", "create", "update", "delete", "query"]
    )
    """The data disk storage tier of the vm size."""
    label: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
    """The label of the vm size."""
    max_data_disk_count: Optional[int] = rest_field(
        name="maxDataDiskCount", visibility=["read", "create", "update", "delete", "query"]
    )
    """The max data disk count of the vm size."""
    memory_in_mb: Optional[int] = rest_field(
        name="memoryInMb", visibility=["read", "create", "update", "delete", "query"]
    )
    """The memory whose unit is MB of the vm size."""
    supported_by_virtual_machines: Optional[bool] = rest_field(
        name="supportedByVirtualMachines", visibility=["read", "create", "update", "delete", "query"]
    )
    """This indicates this vm size is supported by virtual machines or not."""
    supported_by_web_worker_roles: Optional[bool] = rest_field(
        name="supportedByWebWorkerRoles", visibility=["read", "create", "update", "delete", "query"]
    )
    """The indicates this vm size is supported by web worker roles or not."""
    virtual_machine_resource_disk_size_in_mb: Optional[int] = rest_field(
        name="virtualMachineResourceDiskSizeInMb", visibility=["read", "create", "update", "delete", "query"]
    )
    """The virtual machine resource disk size whose unit is MB of the vm size."""
    web_worker_resource_disk_size_in_mb: Optional[int] = rest_field(
        name="webWorkerResourceDiskSizeInMb", visibility=["read", "create", "update", "delete", "query"]
    )
    """The web worker resource disk size whose unit is MB of the vm size."""

    @overload
    def __init__(
        self,
        *,
        name: Optional[str] = None,
        cores: Optional[int] = None,
        data_disk_storage_tier: Optional[str] = None,
        label: Optional[str] = None,
        max_data_disk_count: Optional[int] = None,
        memory_in_mb: Optional[int] = None,
        supported_by_virtual_machines: Optional[bool] = None,
        supported_by_web_worker_roles: Optional[bool] = None,
        virtual_machine_resource_disk_size_in_mb: Optional[int] = None,
        web_worker_resource_disk_size_in_mb: Optional[int] = None,
    ) -> None: ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]) -> None:
        """
        :param mapping: raw JSON to initialize the model.
        :type mapping: Mapping[str, Any]
        """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
