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

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

__all__ = [
    'GroupContainer',
    'GroupContainerGpu',
    'GroupContainerLivenessProbe',
    'GroupContainerLivenessProbeHttpGet',
    'GroupContainerPort',
    'GroupContainerReadinessProbe',
    'GroupContainerReadinessProbeHttpGet',
    'GroupContainerVolume',
    'GroupContainerVolumeGitRepo',
    'GroupDiagnostics',
    'GroupDiagnosticsLogAnalytics',
    'GroupDnsConfig',
    'GroupExposedPort',
    'GroupIdentity',
    'GroupImageRegistryCredential',
    'KubernetesClusterAddonProfile',
    'KubernetesClusterAddonProfileAciConnectorLinux',
    'KubernetesClusterAddonProfileAzureKeyvaultSecretsProvider',
    'KubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentity',
    'KubernetesClusterAddonProfileAzurePolicy',
    'KubernetesClusterAddonProfileHttpApplicationRouting',
    'KubernetesClusterAddonProfileIngressApplicationGateway',
    'KubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentity',
    'KubernetesClusterAddonProfileKubeDashboard',
    'KubernetesClusterAddonProfileOmsAgent',
    'KubernetesClusterAddonProfileOmsAgentOmsAgentIdentity',
    'KubernetesClusterAddonProfileOpenServiceMesh',
    'KubernetesClusterAutoScalerProfile',
    'KubernetesClusterDefaultNodePool',
    'KubernetesClusterDefaultNodePoolKubeletConfig',
    'KubernetesClusterDefaultNodePoolLinuxOsConfig',
    'KubernetesClusterDefaultNodePoolLinuxOsConfigSysctlConfig',
    'KubernetesClusterDefaultNodePoolUpgradeSettings',
    'KubernetesClusterHttpProxyConfig',
    'KubernetesClusterIdentity',
    'KubernetesClusterKubeAdminConfig',
    'KubernetesClusterKubeConfig',
    'KubernetesClusterKubeletIdentity',
    'KubernetesClusterLinuxProfile',
    'KubernetesClusterLinuxProfileSshKey',
    'KubernetesClusterMaintenanceWindow',
    'KubernetesClusterMaintenanceWindowAllowed',
    'KubernetesClusterMaintenanceWindowNotAllowed',
    'KubernetesClusterNetworkProfile',
    'KubernetesClusterNetworkProfileLoadBalancerProfile',
    'KubernetesClusterNetworkProfileNatGatewayProfile',
    'KubernetesClusterNodePoolKubeletConfig',
    'KubernetesClusterNodePoolLinuxOsConfig',
    'KubernetesClusterNodePoolLinuxOsConfigSysctlConfig',
    'KubernetesClusterNodePoolUpgradeSettings',
    'KubernetesClusterRoleBasedAccessControl',
    'KubernetesClusterRoleBasedAccessControlAzureActiveDirectory',
    'KubernetesClusterServicePrincipal',
    'KubernetesClusterWindowsProfile',
    'RegistryEncryption',
    'RegistryGeoreplication',
    'RegistryIdentity',
    'RegistryNetworkRuleSet',
    'RegistryNetworkRuleSetIpRule',
    'RegistryNetworkRuleSetVirtualNetwork',
    'RegistryRetentionPolicy',
    'RegistryTaskAgentSetting',
    'RegistryTaskBaseImageTrigger',
    'RegistryTaskDockerStep',
    'RegistryTaskEncodedStep',
    'RegistryTaskFileStep',
    'RegistryTaskIdentity',
    'RegistryTaskPlatform',
    'RegistryTaskRegistryCredential',
    'RegistryTaskRegistryCredentialCustom',
    'RegistryTaskRegistryCredentialSource',
    'RegistryTaskSourceTrigger',
    'RegistryTaskSourceTriggerAuthentication',
    'RegistryTaskTimerTrigger',
    'RegistryTrustPolicy',
    'GetClusterNodePoolUpgradeSettingResult',
    'GetKubernetesClusterAddonProfileResult',
    'GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderResult',
    'GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentityResult',
    'GetKubernetesClusterAddonProfileAzurePolicyResult',
    'GetKubernetesClusterAddonProfileHttpApplicationRoutingResult',
    'GetKubernetesClusterAddonProfileIngressApplicationGatewayResult',
    'GetKubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentityResult',
    'GetKubernetesClusterAddonProfileKubeDashboardResult',
    'GetKubernetesClusterAddonProfileOmsAgentResult',
    'GetKubernetesClusterAddonProfileOmsAgentOmsAgentIdentityResult',
    'GetKubernetesClusterAddonProfileOpenServiceMeshResult',
    'GetKubernetesClusterAgentPoolProfileResult',
    'GetKubernetesClusterAgentPoolProfileUpgradeSettingResult',
    'GetKubernetesClusterIdentityResult',
    'GetKubernetesClusterKubeAdminConfigResult',
    'GetKubernetesClusterKubeConfigResult',
    'GetKubernetesClusterKubeletIdentityResult',
    'GetKubernetesClusterLinuxProfileResult',
    'GetKubernetesClusterLinuxProfileSshKeyResult',
    'GetKubernetesClusterNetworkProfileResult',
    'GetKubernetesClusterRoleBasedAccessControlResult',
    'GetKubernetesClusterRoleBasedAccessControlAzureActiveDirectoryResult',
    'GetKubernetesClusterServicePrincipalResult',
    'GetKubernetesClusterWindowsProfileResult',
]

@pulumi.output_type
class GroupContainer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "environmentVariables":
            suggest = "environment_variables"
        elif key == "livenessProbe":
            suggest = "liveness_probe"
        elif key == "readinessProbe":
            suggest = "readiness_probe"
        elif key == "secureEnvironmentVariables":
            suggest = "secure_environment_variables"

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

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

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

    def __init__(__self__, *,
                 cpu: float,
                 image: str,
                 memory: float,
                 name: str,
                 commands: Optional[Sequence[str]] = None,
                 environment_variables: Optional[Mapping[str, str]] = None,
                 gpu: Optional['outputs.GroupContainerGpu'] = None,
                 liveness_probe: Optional['outputs.GroupContainerLivenessProbe'] = None,
                 ports: Optional[Sequence['outputs.GroupContainerPort']] = None,
                 readiness_probe: Optional['outputs.GroupContainerReadinessProbe'] = None,
                 secure_environment_variables: Optional[Mapping[str, str]] = None,
                 volumes: Optional[Sequence['outputs.GroupContainerVolume']] = None):
        """
        :param float cpu: The required number of CPU cores of the containers. Changing this forces a new resource to be created.
        :param str image: The container image name. Changing this forces a new resource to be created.
        :param float memory: The required memory of the containers in GB. Changing this forces a new resource to be created.
        :param str name: Specifies the name of the Container Group. Changing this forces a new resource to be created.
        :param Sequence[str] commands: A list of commands which should be run on the container. Changing this forces a new resource to be created.
        :param Mapping[str, str] environment_variables: A list of environment variables to be set on the container. Specified as a map of name/value pairs. Changing this forces a new resource to be created.
        :param 'GroupContainerGpuArgs' gpu: A `gpu` block as defined below. Changing this forces a new resource to be created.
        :param 'GroupContainerLivenessProbeArgs' liveness_probe: The definition of a readiness probe for this container as documented in the `liveness_probe` block below. Changing this forces a new resource to be created.
        :param Sequence['GroupContainerPortArgs'] ports: A set of public ports for the container. Changing this forces a new resource to be created. Set as documented in the `ports` block below.
        :param 'GroupContainerReadinessProbeArgs' readiness_probe: The definition of a readiness probe for this container as documented in the `readiness_probe` block below. Changing this forces a new resource to be created.
        :param Mapping[str, str] secure_environment_variables: A list of sensitive environment variables to be set on the container. Specified as a map of name/value pairs. Changing this forces a new resource to be created.
        :param Sequence['GroupContainerVolumeArgs'] volumes: The definition of a volume mount for this container as documented in the `volume` block below. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "memory", memory)
        pulumi.set(__self__, "name", name)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)
        if environment_variables is not None:
            pulumi.set(__self__, "environment_variables", environment_variables)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)
        if secure_environment_variables is not None:
            pulumi.set(__self__, "secure_environment_variables", secure_environment_variables)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)

    @property
    @pulumi.getter
    def cpu(self) -> float:
        """
        The required number of CPU cores of the containers. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def memory(self) -> float:
        """
        The required memory of the containers in GB. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def commands(self) -> Optional[Sequence[str]]:
        """
        A list of commands which should be run on the container. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "commands")

    @property
    @pulumi.getter(name="environmentVariables")
    def environment_variables(self) -> Optional[Mapping[str, str]]:
        """
        A list of environment variables to be set on the container. Specified as a map of name/value pairs. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "environment_variables")

    @property
    @pulumi.getter
    def gpu(self) -> Optional['outputs.GroupContainerGpu']:
        """
        A `gpu` block as defined below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "gpu")

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.GroupContainerLivenessProbe']:
        """
        The definition of a readiness probe for this container as documented in the `liveness_probe` block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence['outputs.GroupContainerPort']]:
        """
        A set of public ports for the container. Changing this forces a new resource to be created. Set as documented in the `ports` block below.
        """
        return pulumi.get(self, "ports")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GroupContainerReadinessProbe']:
        """
        The definition of a readiness probe for this container as documented in the `readiness_probe` block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "readiness_probe")

    @property
    @pulumi.getter(name="secureEnvironmentVariables")
    def secure_environment_variables(self) -> Optional[Mapping[str, str]]:
        """
        A list of sensitive environment variables to be set on the container. Specified as a map of name/value pairs. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "secure_environment_variables")

    @property
    @pulumi.getter
    def volumes(self) -> Optional[Sequence['outputs.GroupContainerVolume']]:
        """
        The definition of a volume mount for this container as documented in the `volume` block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "volumes")


@pulumi.output_type
class GroupContainerGpu(dict):
    def __init__(__self__, *,
                 count: Optional[int] = None,
                 sku: Optional[str] = None):
        """
        :param int count: The number of GPUs which should be assigned to this container. Allowed values are `1`, `2`, or `4`. Changing this forces a new resource to be created.
        :param str sku: The Sku which should be used for the GPU. Possible values are `K80`, `P100`, or `V100`. Changing this forces a new resource to be created.
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        """
        The number of GPUs which should be assigned to this container. Allowed values are `1`, `2`, or `4`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def sku(self) -> Optional[str]:
        """
        The Sku which should be used for the GPU. Possible values are `K80`, `P100`, or `V100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "sku")


@pulumi.output_type
class GroupContainerLivenessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "httpGets":
            suggest = "http_gets"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 execs: Optional[Sequence[str]] = None,
                 failure_threshold: Optional[int] = None,
                 http_gets: Optional[Sequence['outputs.GroupContainerLivenessProbeHttpGet']] = None,
                 initial_delay_seconds: Optional[int] = None,
                 period_seconds: Optional[int] = None,
                 success_threshold: Optional[int] = None,
                 timeout_seconds: Optional[int] = None):
        """
        :param Sequence[str] execs: Commands to be run to validate container readiness. Changing this forces a new resource to be created.
        :param int failure_threshold: How many times to try the probe before restarting the container (liveness probe) or marking the container as unhealthy (readiness probe). The default value is `3` and the minimum value is `1`. Changing this forces a new resource to be created.
        :param Sequence['GroupContainerLivenessProbeHttpGetArgs'] http_gets: The definition of the http_get for this container as documented in the `http_get` block below. Changing this forces a new resource to be created.
        :param int initial_delay_seconds: Number of seconds after the container has started before liveness or readiness probes are initiated. Changing this forces a new resource to be created.
        :param int period_seconds: How often (in seconds) to perform the probe. The default value is `10` and the minimum value is `1`. Changing this forces a new resource to be created.
        :param int success_threshold: Minimum consecutive successes for the probe to be considered successful after having failed. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        :param int timeout_seconds: Number of seconds after which the probe times out. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        if execs is not None:
            pulumi.set(__self__, "execs", execs)
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_gets is not None:
            pulumi.set(__self__, "http_gets", http_gets)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter
    def execs(self) -> Optional[Sequence[str]]:
        """
        Commands to be run to validate container readiness. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "execs")

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[int]:
        """
        How many times to try the probe before restarting the container (liveness probe) or marking the container as unhealthy (readiness probe). The default value is `3` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="httpGets")
    def http_gets(self) -> Optional[Sequence['outputs.GroupContainerLivenessProbeHttpGet']]:
        """
        The definition of the http_get for this container as documented in the `http_get` block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "http_gets")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[int]:
        """
        Number of seconds after the container has started before liveness or readiness probes are initiated. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[int]:
        """
        How often (in seconds) to perform the probe. The default value is `10` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[int]:
        """
        Minimum consecutive successes for the probe to be considered successful after having failed. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[int]:
        """
        Number of seconds after which the probe times out. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "timeout_seconds")


@pulumi.output_type
class GroupContainerLivenessProbeHttpGet(dict):
    def __init__(__self__, *,
                 path: Optional[str] = None,
                 port: Optional[int] = None,
                 scheme: Optional[str] = None):
        """
        :param str path: Path to access on the HTTP server. Changing this forces a new resource to be created.
        :param int port: The port number the container will expose. Changing this forces a new resource to be created.
        :param str scheme: Scheme to use for connecting to the host. Possible values are `Http` and `Https`. Changing this forces a new resource to be created.
        """
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        Path to access on the HTTP server. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number the container will expose. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> Optional[str]:
        """
        Scheme to use for connecting to the host. Possible values are `Http` and `Https`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "scheme")


@pulumi.output_type
class GroupContainerPort(dict):
    def __init__(__self__, *,
                 port: Optional[int] = None,
                 protocol: Optional[str] = None):
        """
        :param int port: The port number the container will expose. Changing this forces a new resource to be created.
        :param str protocol: The network protocol associated with port. Possible values are `TCP` & `UDP`. Changing this forces a new resource to be created.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number the container will expose. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The network protocol associated with port. Possible values are `TCP` & `UDP`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class GroupContainerReadinessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "httpGets":
            suggest = "http_gets"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 execs: Optional[Sequence[str]] = None,
                 failure_threshold: Optional[int] = None,
                 http_gets: Optional[Sequence['outputs.GroupContainerReadinessProbeHttpGet']] = None,
                 initial_delay_seconds: Optional[int] = None,
                 period_seconds: Optional[int] = None,
                 success_threshold: Optional[int] = None,
                 timeout_seconds: Optional[int] = None):
        """
        :param Sequence[str] execs: Commands to be run to validate container readiness. Changing this forces a new resource to be created.
        :param int failure_threshold: How many times to try the probe before restarting the container (liveness probe) or marking the container as unhealthy (readiness probe). The default value is `3` and the minimum value is `1`. Changing this forces a new resource to be created.
        :param Sequence['GroupContainerReadinessProbeHttpGetArgs'] http_gets: The definition of the http_get for this container as documented in the `http_get` block below. Changing this forces a new resource to be created.
        :param int initial_delay_seconds: Number of seconds after the container has started before liveness or readiness probes are initiated. Changing this forces a new resource to be created.
        :param int period_seconds: How often (in seconds) to perform the probe. The default value is `10` and the minimum value is `1`. Changing this forces a new resource to be created.
        :param int success_threshold: Minimum consecutive successes for the probe to be considered successful after having failed. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        :param int timeout_seconds: Number of seconds after which the probe times out. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        if execs is not None:
            pulumi.set(__self__, "execs", execs)
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_gets is not None:
            pulumi.set(__self__, "http_gets", http_gets)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter
    def execs(self) -> Optional[Sequence[str]]:
        """
        Commands to be run to validate container readiness. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "execs")

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[int]:
        """
        How many times to try the probe before restarting the container (liveness probe) or marking the container as unhealthy (readiness probe). The default value is `3` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="httpGets")
    def http_gets(self) -> Optional[Sequence['outputs.GroupContainerReadinessProbeHttpGet']]:
        """
        The definition of the http_get for this container as documented in the `http_get` block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "http_gets")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[int]:
        """
        Number of seconds after the container has started before liveness or readiness probes are initiated. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[int]:
        """
        How often (in seconds) to perform the probe. The default value is `10` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[int]:
        """
        Minimum consecutive successes for the probe to be considered successful after having failed. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[int]:
        """
        Number of seconds after which the probe times out. The default value is `1` and the minimum value is `1`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "timeout_seconds")


@pulumi.output_type
class GroupContainerReadinessProbeHttpGet(dict):
    def __init__(__self__, *,
                 path: Optional[str] = None,
                 port: Optional[int] = None,
                 scheme: Optional[str] = None):
        """
        :param str path: Path to access on the HTTP server. Changing this forces a new resource to be created.
        :param int port: The port number the container will expose. Changing this forces a new resource to be created.
        :param str scheme: Scheme to use for connecting to the host. Possible values are `Http` and `Https`. Changing this forces a new resource to be created.
        """
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        Path to access on the HTTP server. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number the container will expose. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> Optional[str]:
        """
        Scheme to use for connecting to the host. Possible values are `Http` and `Https`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "scheme")


@pulumi.output_type
class GroupContainerVolume(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPath":
            suggest = "mount_path"
        elif key == "emptyDir":
            suggest = "empty_dir"
        elif key == "gitRepo":
            suggest = "git_repo"
        elif key == "readOnly":
            suggest = "read_only"
        elif key == "shareName":
            suggest = "share_name"
        elif key == "storageAccountKey":
            suggest = "storage_account_key"
        elif key == "storageAccountName":
            suggest = "storage_account_name"

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

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

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

    def __init__(__self__, *,
                 mount_path: str,
                 name: str,
                 empty_dir: Optional[bool] = None,
                 git_repo: Optional['outputs.GroupContainerVolumeGitRepo'] = None,
                 read_only: Optional[bool] = None,
                 secret: Optional[Mapping[str, str]] = None,
                 share_name: Optional[str] = None,
                 storage_account_key: Optional[str] = None,
                 storage_account_name: Optional[str] = None):
        """
        :param str mount_path: The path on which this volume is to be mounted. Changing this forces a new resource to be created.
        :param str name: Specifies the name of the Container Group. Changing this forces a new resource to be created.
        :param bool empty_dir: Boolean as to whether the mounted volume should be an empty directory. Defaults to `false`. Changing this forces a new resource to be created.
        :param 'GroupContainerVolumeGitRepoArgs' git_repo: A `git_repo` block as defined below.
        :param bool read_only: Specify if the volume is to be mounted as read only or not. The default value is `false`. Changing this forces a new resource to be created.
        :param Mapping[str, str] secret: A map of secrets that will be mounted as files in the volume. Changing this forces a new resource to be created.
        :param str share_name: The Azure storage share that is to be mounted as a volume. This must be created on the storage account specified as above. Changing this forces a new resource to be created.
        :param str storage_account_key: The access key for the Azure Storage account specified as above. Changing this forces a new resource to be created.
        :param str storage_account_name: The Azure storage account from which the volume is to be mounted. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "mount_path", mount_path)
        pulumi.set(__self__, "name", name)
        if empty_dir is not None:
            pulumi.set(__self__, "empty_dir", empty_dir)
        if git_repo is not None:
            pulumi.set(__self__, "git_repo", git_repo)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if share_name is not None:
            pulumi.set(__self__, "share_name", share_name)
        if storage_account_key is not None:
            pulumi.set(__self__, "storage_account_key", storage_account_key)
        if storage_account_name is not None:
            pulumi.set(__self__, "storage_account_name", storage_account_name)

    @property
    @pulumi.getter(name="mountPath")
    def mount_path(self) -> str:
        """
        The path on which this volume is to be mounted. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "mount_path")

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

    @property
    @pulumi.getter(name="emptyDir")
    def empty_dir(self) -> Optional[bool]:
        """
        Boolean as to whether the mounted volume should be an empty directory. Defaults to `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "empty_dir")

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

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[bool]:
        """
        Specify if the volume is to be mounted as read only or not. The default value is `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "read_only")

    @property
    @pulumi.getter
    def secret(self) -> Optional[Mapping[str, str]]:
        """
        A map of secrets that will be mounted as files in the volume. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="shareName")
    def share_name(self) -> Optional[str]:
        """
        The Azure storage share that is to be mounted as a volume. This must be created on the storage account specified as above. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "share_name")

    @property
    @pulumi.getter(name="storageAccountKey")
    def storage_account_key(self) -> Optional[str]:
        """
        The access key for the Azure Storage account specified as above. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_key")

    @property
    @pulumi.getter(name="storageAccountName")
    def storage_account_name(self) -> Optional[str]:
        """
        The Azure storage account from which the volume is to be mounted. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "storage_account_name")


@pulumi.output_type
class GroupContainerVolumeGitRepo(dict):
    def __init__(__self__, *,
                 url: str,
                 directory: Optional[str] = None,
                 revision: Optional[str] = None):
        """
        :param str url: Specifies the Git repository to be cloned. Changing this forces a new resource to be created.
        :param str directory: Specifies the directory into which the repository should be cloned. Changing this forces a new resource to be created.
        :param str revision: Specifies the commit hash of the revision to be cloned. If unspecified, the HEAD revision is cloned. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "url", url)
        if directory is not None:
            pulumi.set(__self__, "directory", directory)
        if revision is not None:
            pulumi.set(__self__, "revision", revision)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Specifies the Git repository to be cloned. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter
    def directory(self) -> Optional[str]:
        """
        Specifies the directory into which the repository should be cloned. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "directory")

    @property
    @pulumi.getter
    def revision(self) -> Optional[str]:
        """
        Specifies the commit hash of the revision to be cloned. If unspecified, the HEAD revision is cloned. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "revision")


@pulumi.output_type
class GroupDiagnostics(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalytics":
            suggest = "log_analytics"

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

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

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

    def __init__(__self__, *,
                 log_analytics: 'outputs.GroupDiagnosticsLogAnalytics'):
        """
        :param 'GroupDiagnosticsLogAnalyticsArgs' log_analytics: A `log_analytics` block as defined below. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "log_analytics", log_analytics)

    @property
    @pulumi.getter(name="logAnalytics")
    def log_analytics(self) -> 'outputs.GroupDiagnosticsLogAnalytics':
        """
        A `log_analytics` block as defined below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "log_analytics")


@pulumi.output_type
class GroupDiagnosticsLogAnalytics(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "workspaceId":
            suggest = "workspace_id"
        elif key == "workspaceKey":
            suggest = "workspace_key"
        elif key == "logType":
            suggest = "log_type"

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

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

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

    def __init__(__self__, *,
                 workspace_id: str,
                 workspace_key: str,
                 log_type: Optional[str] = None,
                 metadata: Optional[Mapping[str, str]] = None):
        """
        :param str workspace_id: The Workspace ID of the Log Analytics Workspace. Changing this forces a new resource to be created.
        :param str workspace_key: The Workspace Key of the Log Analytics Workspace. Changing this forces a new resource to be created.
        :param str log_type: The log type which should be used. Possible values are `ContainerInsights` and `ContainerInstanceLogs`. Changing this forces a new resource to be created.
        :param Mapping[str, str] metadata: Any metadata required for Log Analytics. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "workspace_id", workspace_id)
        pulumi.set(__self__, "workspace_key", workspace_key)
        if log_type is not None:
            pulumi.set(__self__, "log_type", log_type)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> str:
        """
        The Workspace ID of the Log Analytics Workspace. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "workspace_id")

    @property
    @pulumi.getter(name="workspaceKey")
    def workspace_key(self) -> str:
        """
        The Workspace Key of the Log Analytics Workspace. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "workspace_key")

    @property
    @pulumi.getter(name="logType")
    def log_type(self) -> Optional[str]:
        """
        The log type which should be used. Possible values are `ContainerInsights` and `ContainerInstanceLogs`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "log_type")

    @property
    @pulumi.getter
    def metadata(self) -> Optional[Mapping[str, str]]:
        """
        Any metadata required for Log Analytics. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "metadata")


@pulumi.output_type
class GroupDnsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "searchDomains":
            suggest = "search_domains"

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

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

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

    def __init__(__self__, *,
                 nameservers: Sequence[str],
                 options: Optional[Sequence[str]] = None,
                 search_domains: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] nameservers: A list of nameservers the containers will search out to resolve requests.
        :param Sequence[str] options: A list of [resolver configuration options](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
        :param Sequence[str] search_domains: A list of search domains that DNS requests will search along.
        """
        pulumi.set(__self__, "nameservers", nameservers)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if search_domains is not None:
            pulumi.set(__self__, "search_domains", search_domains)

    @property
    @pulumi.getter
    def nameservers(self) -> Sequence[str]:
        """
        A list of nameservers the containers will search out to resolve requests.
        """
        return pulumi.get(self, "nameservers")

    @property
    @pulumi.getter
    def options(self) -> Optional[Sequence[str]]:
        """
        A list of [resolver configuration options](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
        """
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="searchDomains")
    def search_domains(self) -> Optional[Sequence[str]]:
        """
        A list of search domains that DNS requests will search along.
        """
        return pulumi.get(self, "search_domains")


@pulumi.output_type
class GroupExposedPort(dict):
    def __init__(__self__, *,
                 port: Optional[int] = None,
                 protocol: Optional[str] = None):
        """
        :param int port: The port number the container will expose. Changing this forces a new resource to be created.
        :param str protocol: The network protocol associated with port. Possible values are `TCP` & `UDP`. Changing this forces a new resource to be created.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number the container will expose. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The network protocol associated with port. Possible values are `TCP` & `UDP`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "protocol")


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

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

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

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

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None):
        """
        :param str type: The Managed Service Identity Type of this container group. Possible values are `SystemAssigned` (where Azure will generate a Service Principal for you), `UserAssigned` where you can specify the Service Principal IDs in the `identity_ids` field, and `SystemAssigned, UserAssigned` which assigns both a system managed identity as well as the specified user assigned identities. Changing this forces a new resource to be created.
        :param Sequence[str] identity_ids: Specifies a list of user managed identity ids to be assigned. Required if `type` is `UserAssigned`. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The Managed Service Identity Type of this container group. Possible values are `SystemAssigned` (where Azure will generate a Service Principal for you), `UserAssigned` where you can specify the Service Principal IDs in the `identity_ids` field, and `SystemAssigned, UserAssigned` which assigns both a system managed identity as well as the specified user assigned identities. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of user managed identity ids to be assigned. Required if `type` is `UserAssigned`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "identity_ids")

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


@pulumi.output_type
class GroupImageRegistryCredential(dict):
    def __init__(__self__, *,
                 password: str,
                 server: str,
                 username: str):
        """
        :param str password: The password with which to connect to the registry. Changing this forces a new resource to be created.
        :param str server: The address to use to connect to the registry without protocol ("https"/"http"). For example: "myacr.acr.io". Changing this forces a new resource to be created.
        :param str username: The username with which to connect to the registry. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password with which to connect to the registry. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def server(self) -> str:
        """
        The address to use to connect to the registry without protocol ("https"/"http"). For example: "myacr.acr.io". Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "server")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username with which to connect to the registry. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class KubernetesClusterAddonProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aciConnectorLinux":
            suggest = "aci_connector_linux"
        elif key == "azureKeyvaultSecretsProvider":
            suggest = "azure_keyvault_secrets_provider"
        elif key == "azurePolicy":
            suggest = "azure_policy"
        elif key == "httpApplicationRouting":
            suggest = "http_application_routing"
        elif key == "ingressApplicationGateway":
            suggest = "ingress_application_gateway"
        elif key == "kubeDashboard":
            suggest = "kube_dashboard"
        elif key == "omsAgent":
            suggest = "oms_agent"
        elif key == "openServiceMesh":
            suggest = "open_service_mesh"

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

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

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

    def __init__(__self__, *,
                 aci_connector_linux: Optional['outputs.KubernetesClusterAddonProfileAciConnectorLinux'] = None,
                 azure_keyvault_secrets_provider: Optional['outputs.KubernetesClusterAddonProfileAzureKeyvaultSecretsProvider'] = None,
                 azure_policy: Optional['outputs.KubernetesClusterAddonProfileAzurePolicy'] = None,
                 http_application_routing: Optional['outputs.KubernetesClusterAddonProfileHttpApplicationRouting'] = None,
                 ingress_application_gateway: Optional['outputs.KubernetesClusterAddonProfileIngressApplicationGateway'] = None,
                 kube_dashboard: Optional['outputs.KubernetesClusterAddonProfileKubeDashboard'] = None,
                 oms_agent: Optional['outputs.KubernetesClusterAddonProfileOmsAgent'] = None,
                 open_service_mesh: Optional['outputs.KubernetesClusterAddonProfileOpenServiceMesh'] = None):
        """
        :param 'KubernetesClusterAddonProfileAciConnectorLinuxArgs' aci_connector_linux: A `aci_connector_linux` block. For more details, please visit [Create and configure an AKS cluster to use virtual nodes](https://docs.microsoft.com/en-us/azure/aks/virtual-nodes-portal).
        :param 'KubernetesClusterAddonProfileAzureKeyvaultSecretsProviderArgs' azure_keyvault_secrets_provider: An `azure_keyvault_secrets_provider` block as defined below. For more details, please visit [Azure Keyvault Secrets Provider for AKS](https://docs.microsoft.com/en-us/azure/aks/csi-secrets-store-driver).
        :param 'KubernetesClusterAddonProfileAzurePolicyArgs' azure_policy: A `azure_policy` block as defined below. For more details please visit [Understand Azure Policy for Azure Kubernetes Service](https://docs.microsoft.com/en-ie/azure/governance/policy/concepts/rego-for-aks)
        :param 'KubernetesClusterAddonProfileHttpApplicationRoutingArgs' http_application_routing: A `http_application_routing` block as defined below.
        :param 'KubernetesClusterAddonProfileIngressApplicationGatewayArgs' ingress_application_gateway: An `ingress_application_gateway` block as defined below.
        :param 'KubernetesClusterAddonProfileKubeDashboardArgs' kube_dashboard: A `kube_dashboard` block as defined below.
        :param 'KubernetesClusterAddonProfileOmsAgentArgs' oms_agent: A `oms_agent` block as defined below. For more details, please visit [How to onboard Azure Monitor for containers](https://docs.microsoft.com/en-us/azure/monitoring/monitoring-container-insights-onboard).
        :param 'KubernetesClusterAddonProfileOpenServiceMeshArgs' open_service_mesh: An `open_service_mesh` block as defined below. For more details, please visit [Open Service Mesh for AKS](https://docs.microsoft.com/azure/aks/open-service-mesh-about).
        """
        if aci_connector_linux is not None:
            pulumi.set(__self__, "aci_connector_linux", aci_connector_linux)
        if azure_keyvault_secrets_provider is not None:
            pulumi.set(__self__, "azure_keyvault_secrets_provider", azure_keyvault_secrets_provider)
        if azure_policy is not None:
            pulumi.set(__self__, "azure_policy", azure_policy)
        if http_application_routing is not None:
            pulumi.set(__self__, "http_application_routing", http_application_routing)
        if ingress_application_gateway is not None:
            pulumi.set(__self__, "ingress_application_gateway", ingress_application_gateway)
        if kube_dashboard is not None:
            pulumi.set(__self__, "kube_dashboard", kube_dashboard)
        if oms_agent is not None:
            pulumi.set(__self__, "oms_agent", oms_agent)
        if open_service_mesh is not None:
            pulumi.set(__self__, "open_service_mesh", open_service_mesh)

    @property
    @pulumi.getter(name="aciConnectorLinux")
    def aci_connector_linux(self) -> Optional['outputs.KubernetesClusterAddonProfileAciConnectorLinux']:
        """
        A `aci_connector_linux` block. For more details, please visit [Create and configure an AKS cluster to use virtual nodes](https://docs.microsoft.com/en-us/azure/aks/virtual-nodes-portal).
        """
        return pulumi.get(self, "aci_connector_linux")

    @property
    @pulumi.getter(name="azureKeyvaultSecretsProvider")
    def azure_keyvault_secrets_provider(self) -> Optional['outputs.KubernetesClusterAddonProfileAzureKeyvaultSecretsProvider']:
        """
        An `azure_keyvault_secrets_provider` block as defined below. For more details, please visit [Azure Keyvault Secrets Provider for AKS](https://docs.microsoft.com/en-us/azure/aks/csi-secrets-store-driver).
        """
        return pulumi.get(self, "azure_keyvault_secrets_provider")

    @property
    @pulumi.getter(name="azurePolicy")
    def azure_policy(self) -> Optional['outputs.KubernetesClusterAddonProfileAzurePolicy']:
        """
        A `azure_policy` block as defined below. For more details please visit [Understand Azure Policy for Azure Kubernetes Service](https://docs.microsoft.com/en-ie/azure/governance/policy/concepts/rego-for-aks)
        """
        return pulumi.get(self, "azure_policy")

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

    @property
    @pulumi.getter(name="ingressApplicationGateway")
    def ingress_application_gateway(self) -> Optional['outputs.KubernetesClusterAddonProfileIngressApplicationGateway']:
        """
        An `ingress_application_gateway` block as defined below.
        """
        return pulumi.get(self, "ingress_application_gateway")

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

    @property
    @pulumi.getter(name="omsAgent")
    def oms_agent(self) -> Optional['outputs.KubernetesClusterAddonProfileOmsAgent']:
        """
        A `oms_agent` block as defined below. For more details, please visit [How to onboard Azure Monitor for containers](https://docs.microsoft.com/en-us/azure/monitoring/monitoring-container-insights-onboard).
        """
        return pulumi.get(self, "oms_agent")

    @property
    @pulumi.getter(name="openServiceMesh")
    def open_service_mesh(self) -> Optional['outputs.KubernetesClusterAddonProfileOpenServiceMesh']:
        """
        An `open_service_mesh` block as defined below. For more details, please visit [Open Service Mesh for AKS](https://docs.microsoft.com/azure/aks/open-service-mesh-about).
        """
        return pulumi.get(self, "open_service_mesh")


@pulumi.output_type
class KubernetesClusterAddonProfileAciConnectorLinux(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetName":
            suggest = "subnet_name"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 subnet_name: Optional[str] = None):
        """
        :param bool enabled: Is the virtual node addon enabled?
        :param str subnet_name: The subnet name for the virtual nodes to run. This is required when `aci_connector_linux` `enabled` argument is set to `true`.
        """
        pulumi.set(__self__, "enabled", enabled)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the virtual node addon enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> Optional[str]:
        """
        The subnet name for the virtual nodes to run. This is required when `aci_connector_linux` `enabled` argument is set to `true`.
        """
        return pulumi.get(self, "subnet_name")


@pulumi.output_type
class KubernetesClusterAddonProfileAzureKeyvaultSecretsProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretIdentities":
            suggest = "secret_identities"
        elif key == "secretRotationEnabled":
            suggest = "secret_rotation_enabled"
        elif key == "secretRotationInterval":
            suggest = "secret_rotation_interval"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 secret_identities: Optional[Sequence['outputs.KubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentity']] = None,
                 secret_rotation_enabled: Optional[bool] = None,
                 secret_rotation_interval: Optional[str] = None):
        """
        :param bool enabled: Is the Azure Keyvault Secrets Providerenabled?
        :param Sequence['KubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentityArgs'] secret_identities: An `secret_identity` block is exported. The exported attributes are defined below.
        :param bool secret_rotation_enabled: Is secret rotation enabled?
        :param str secret_rotation_interval: The interval to poll for secret rotation. This attribute is only set when `secret_rotation` is true and defaults to `2m`.
        """
        pulumi.set(__self__, "enabled", enabled)
        if secret_identities is not None:
            pulumi.set(__self__, "secret_identities", secret_identities)
        if secret_rotation_enabled is not None:
            pulumi.set(__self__, "secret_rotation_enabled", secret_rotation_enabled)
        if secret_rotation_interval is not None:
            pulumi.set(__self__, "secret_rotation_interval", secret_rotation_interval)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the Azure Keyvault Secrets Providerenabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="secretIdentities")
    def secret_identities(self) -> Optional[Sequence['outputs.KubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentity']]:
        """
        An `secret_identity` block is exported. The exported attributes are defined below.
        """
        return pulumi.get(self, "secret_identities")

    @property
    @pulumi.getter(name="secretRotationEnabled")
    def secret_rotation_enabled(self) -> Optional[bool]:
        """
        Is secret rotation enabled?
        """
        return pulumi.get(self, "secret_rotation_enabled")

    @property
    @pulumi.getter(name="secretRotationInterval")
    def secret_rotation_interval(self) -> Optional[str]:
        """
        The interval to poll for secret rotation. This attribute is only set when `secret_rotation` is true and defaults to `2m`.
        """
        return pulumi.get(self, "secret_rotation_interval")


@pulumi.output_type
class KubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "objectId":
            suggest = "object_id"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 object_id: Optional[str] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        :param str user_assigned_identity_id: The ID of a user assigned identity.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if object_id is not None:
            pulumi.set(__self__, "object_id", object_id)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> Optional[str]:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[str]:
        """
        The ID of a user assigned identity.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class KubernetesClusterAddonProfileAzurePolicy(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Is the Azure Policy for Kubernetes Add On enabled?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the Azure Policy for Kubernetes Add On enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class KubernetesClusterAddonProfileHttpApplicationRouting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpApplicationRoutingZoneName":
            suggest = "http_application_routing_zone_name"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 http_application_routing_zone_name: Optional[str] = None):
        """
        :param bool enabled: Is HTTP Application Routing Enabled?
        :param str http_application_routing_zone_name: The Zone Name of the HTTP Application Routing.
        """
        pulumi.set(__self__, "enabled", enabled)
        if http_application_routing_zone_name is not None:
            pulumi.set(__self__, "http_application_routing_zone_name", http_application_routing_zone_name)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is HTTP Application Routing Enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="httpApplicationRoutingZoneName")
    def http_application_routing_zone_name(self) -> Optional[str]:
        """
        The Zone Name of the HTTP Application Routing.
        """
        return pulumi.get(self, "http_application_routing_zone_name")


@pulumi.output_type
class KubernetesClusterAddonProfileIngressApplicationGateway(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "effectiveGatewayId":
            suggest = "effective_gateway_id"
        elif key == "gatewayId":
            suggest = "gateway_id"
        elif key == "gatewayName":
            suggest = "gateway_name"
        elif key == "ingressApplicationGatewayIdentities":
            suggest = "ingress_application_gateway_identities"
        elif key == "subnetCidr":
            suggest = "subnet_cidr"
        elif key == "subnetId":
            suggest = "subnet_id"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 effective_gateway_id: Optional[str] = None,
                 gateway_id: Optional[str] = None,
                 gateway_name: Optional[str] = None,
                 ingress_application_gateway_identities: Optional[Sequence['outputs.KubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentity']] = None,
                 subnet_cidr: Optional[str] = None,
                 subnet_id: Optional[str] = None):
        """
        :param bool enabled: Whether to deploy the Application Gateway ingress controller to this Kubernetes Cluster?
        :param str effective_gateway_id: The ID of the Application Gateway associated with the ingress controller deployed to this Kubernetes Cluster.
        :param str gateway_id: The ID of the Application Gateway to integrate with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-existing) page for further details.
        :param str gateway_name: The name of the Application Gateway to be used or created in the Nodepool Resource Group, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-new) page for further details.
        :param Sequence['KubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentityArgs'] ingress_application_gateway_identities: An `ingress_application_gateway_identity` block is exported. The exported attributes are defined below.
        :param str subnet_cidr: The subnet CIDR to be used to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-new) page for further details.
        :param str subnet_id: The ID of the subnet on which to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-new) page for further details.
        """
        pulumi.set(__self__, "enabled", enabled)
        if effective_gateway_id is not None:
            pulumi.set(__self__, "effective_gateway_id", effective_gateway_id)
        if gateway_id is not None:
            pulumi.set(__self__, "gateway_id", gateway_id)
        if gateway_name is not None:
            pulumi.set(__self__, "gateway_name", gateway_name)
        if ingress_application_gateway_identities is not None:
            pulumi.set(__self__, "ingress_application_gateway_identities", ingress_application_gateway_identities)
        if subnet_cidr is not None:
            pulumi.set(__self__, "subnet_cidr", subnet_cidr)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether to deploy the Application Gateway ingress controller to this Kubernetes Cluster?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="effectiveGatewayId")
    def effective_gateway_id(self) -> Optional[str]:
        """
        The ID of the Application Gateway associated with the ingress controller deployed to this Kubernetes Cluster.
        """
        return pulumi.get(self, "effective_gateway_id")

    @property
    @pulumi.getter(name="gatewayId")
    def gateway_id(self) -> Optional[str]:
        """
        The ID of the Application Gateway to integrate with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-existing) page for further details.
        """
        return pulumi.get(self, "gateway_id")

    @property
    @pulumi.getter(name="gatewayName")
    def gateway_name(self) -> Optional[str]:
        """
        The name of the Application Gateway to be used or created in the Nodepool Resource Group, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-new) page for further details.
        """
        return pulumi.get(self, "gateway_name")

    @property
    @pulumi.getter(name="ingressApplicationGatewayIdentities")
    def ingress_application_gateway_identities(self) -> Optional[Sequence['outputs.KubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentity']]:
        """
        An `ingress_application_gateway_identity` block is exported. The exported attributes are defined below.
        """
        return pulumi.get(self, "ingress_application_gateway_identities")

    @property
    @pulumi.getter(name="subnetCidr")
    def subnet_cidr(self) -> Optional[str]:
        """
        The subnet CIDR to be used to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-new) page for further details.
        """
        return pulumi.get(self, "subnet_cidr")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the subnet on which to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. See [this](https://docs.microsoft.com/en-us/azure/application-gateway/tutorial-ingress-controller-add-on-new) page for further details.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class KubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "objectId":
            suggest = "object_id"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 object_id: Optional[str] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        :param str user_assigned_identity_id: The ID of a user assigned identity.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if object_id is not None:
            pulumi.set(__self__, "object_id", object_id)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> Optional[str]:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[str]:
        """
        The ID of a user assigned identity.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class KubernetesClusterAddonProfileKubeDashboard(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Is the Kubernetes Dashboard enabled?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the Kubernetes Dashboard enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class KubernetesClusterAddonProfileOmsAgent(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logAnalyticsWorkspaceId":
            suggest = "log_analytics_workspace_id"
        elif key == "omsAgentIdentities":
            suggest = "oms_agent_identities"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 log_analytics_workspace_id: Optional[str] = None,
                 oms_agent_identities: Optional[Sequence['outputs.KubernetesClusterAddonProfileOmsAgentOmsAgentIdentity']] = None):
        """
        :param bool enabled: Is the OMS Agent Enabled?
        :param str log_analytics_workspace_id: The ID of the Log Analytics Workspace which the OMS Agent should send data to. Must be present if `enabled` is `true`.
        :param Sequence['KubernetesClusterAddonProfileOmsAgentOmsAgentIdentityArgs'] oms_agent_identities: An `oms_agent_identity` block is exported. The exported attributes are defined below.
        """
        pulumi.set(__self__, "enabled", enabled)
        if log_analytics_workspace_id is not None:
            pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        if oms_agent_identities is not None:
            pulumi.set(__self__, "oms_agent_identities", oms_agent_identities)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the OMS Agent Enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> Optional[str]:
        """
        The ID of the Log Analytics Workspace which the OMS Agent should send data to. Must be present if `enabled` is `true`.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="omsAgentIdentities")
    def oms_agent_identities(self) -> Optional[Sequence['outputs.KubernetesClusterAddonProfileOmsAgentOmsAgentIdentity']]:
        """
        An `oms_agent_identity` block is exported. The exported attributes are defined below.
        """
        return pulumi.get(self, "oms_agent_identities")


@pulumi.output_type
class KubernetesClusterAddonProfileOmsAgentOmsAgentIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "objectId":
            suggest = "object_id"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 object_id: Optional[str] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        :param str user_assigned_identity_id: The ID of a user assigned identity.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if object_id is not None:
            pulumi.set(__self__, "object_id", object_id)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> Optional[str]:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[str]:
        """
        The ID of a user assigned identity.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class KubernetesClusterAddonProfileOpenServiceMesh(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Is Open Service Mesh enabled?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Open Service Mesh enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class KubernetesClusterAutoScalerProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "balanceSimilarNodeGroups":
            suggest = "balance_similar_node_groups"
        elif key == "emptyBulkDeleteMax":
            suggest = "empty_bulk_delete_max"
        elif key == "maxGracefulTerminationSec":
            suggest = "max_graceful_termination_sec"
        elif key == "maxNodeProvisioningTime":
            suggest = "max_node_provisioning_time"
        elif key == "maxUnreadyNodes":
            suggest = "max_unready_nodes"
        elif key == "maxUnreadyPercentage":
            suggest = "max_unready_percentage"
        elif key == "newPodScaleUpDelay":
            suggest = "new_pod_scale_up_delay"
        elif key == "scaleDownDelayAfterAdd":
            suggest = "scale_down_delay_after_add"
        elif key == "scaleDownDelayAfterDelete":
            suggest = "scale_down_delay_after_delete"
        elif key == "scaleDownDelayAfterFailure":
            suggest = "scale_down_delay_after_failure"
        elif key == "scaleDownUnneeded":
            suggest = "scale_down_unneeded"
        elif key == "scaleDownUnready":
            suggest = "scale_down_unready"
        elif key == "scaleDownUtilizationThreshold":
            suggest = "scale_down_utilization_threshold"
        elif key == "scanInterval":
            suggest = "scan_interval"
        elif key == "skipNodesWithLocalStorage":
            suggest = "skip_nodes_with_local_storage"
        elif key == "skipNodesWithSystemPods":
            suggest = "skip_nodes_with_system_pods"

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

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

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

    def __init__(__self__, *,
                 balance_similar_node_groups: Optional[bool] = None,
                 empty_bulk_delete_max: Optional[str] = None,
                 expander: Optional[str] = None,
                 max_graceful_termination_sec: Optional[str] = None,
                 max_node_provisioning_time: Optional[str] = None,
                 max_unready_nodes: Optional[int] = None,
                 max_unready_percentage: Optional[float] = None,
                 new_pod_scale_up_delay: Optional[str] = None,
                 scale_down_delay_after_add: Optional[str] = None,
                 scale_down_delay_after_delete: Optional[str] = None,
                 scale_down_delay_after_failure: Optional[str] = None,
                 scale_down_unneeded: Optional[str] = None,
                 scale_down_unready: Optional[str] = None,
                 scale_down_utilization_threshold: Optional[str] = None,
                 scan_interval: Optional[str] = None,
                 skip_nodes_with_local_storage: Optional[bool] = None,
                 skip_nodes_with_system_pods: Optional[bool] = None):
        """
        :param bool balance_similar_node_groups: Detect similar node groups and balance the number of nodes between them. Defaults to `false`.
        :param str empty_bulk_delete_max: Maximum number of empty nodes that can be deleted at the same time. Defaults to `10`.
        :param str expander: Expander to use. Possible values are `least-waste`, `priority`, `most-pods` and `random`. Defaults to `random`.
        :param str max_graceful_termination_sec: Maximum number of seconds the cluster autoscaler waits for pod termination when trying to scale down a node. Defaults to `600`.
        :param str max_node_provisioning_time: Maximum time the autoscaler waits for a node to be provisioned. Defaults to `15m`.
        :param int max_unready_nodes: Maximum Number of allowed unready nodes. Defaults to `3`.
        :param float max_unready_percentage: Maximum percentage of unready nodes the cluster autoscaler will stop if the percentage is exceeded. Defaults to `45`.
        :param str new_pod_scale_up_delay: For scenarios like burst/batch scale where you don't want CA to act before the kubernetes scheduler could schedule all the pods, you can tell CA to ignore unscheduled pods before they're a certain age. Defaults to `10s`.
        :param str scale_down_delay_after_add: How long after the scale up of AKS nodes the scale down evaluation resumes. Defaults to `10m`.
        :param str scale_down_delay_after_delete: How long after node deletion that scale down evaluation resumes. Defaults to the value used for `scan_interval`.
        :param str scale_down_delay_after_failure: How long after scale down failure that scale down evaluation resumes. Defaults to `3m`.
        :param str scale_down_unneeded: How long a node should be unneeded before it is eligible for scale down. Defaults to `10m`.
        :param str scale_down_unready: How long an unready node should be unneeded before it is eligible for scale down. Defaults to `20m`.
        :param str scale_down_utilization_threshold: Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down. Defaults to `0.5`.
        :param str scan_interval: How often the AKS Cluster should be re-evaluated for scale up/down. Defaults to `10s`.
        :param bool skip_nodes_with_local_storage: If `true` cluster autoscaler will never delete nodes with pods with local storage, for example, EmptyDir or HostPath. Defaults to `true`.
        :param bool skip_nodes_with_system_pods: If `true` cluster autoscaler will never delete nodes with pods from kube-system (except for DaemonSet or mirror pods). Defaults to `true`.
        """
        if balance_similar_node_groups is not None:
            pulumi.set(__self__, "balance_similar_node_groups", balance_similar_node_groups)
        if empty_bulk_delete_max is not None:
            pulumi.set(__self__, "empty_bulk_delete_max", empty_bulk_delete_max)
        if expander is not None:
            pulumi.set(__self__, "expander", expander)
        if max_graceful_termination_sec is not None:
            pulumi.set(__self__, "max_graceful_termination_sec", max_graceful_termination_sec)
        if max_node_provisioning_time is not None:
            pulumi.set(__self__, "max_node_provisioning_time", max_node_provisioning_time)
        if max_unready_nodes is not None:
            pulumi.set(__self__, "max_unready_nodes", max_unready_nodes)
        if max_unready_percentage is not None:
            pulumi.set(__self__, "max_unready_percentage", max_unready_percentage)
        if new_pod_scale_up_delay is not None:
            pulumi.set(__self__, "new_pod_scale_up_delay", new_pod_scale_up_delay)
        if scale_down_delay_after_add is not None:
            pulumi.set(__self__, "scale_down_delay_after_add", scale_down_delay_after_add)
        if scale_down_delay_after_delete is not None:
            pulumi.set(__self__, "scale_down_delay_after_delete", scale_down_delay_after_delete)
        if scale_down_delay_after_failure is not None:
            pulumi.set(__self__, "scale_down_delay_after_failure", scale_down_delay_after_failure)
        if scale_down_unneeded is not None:
            pulumi.set(__self__, "scale_down_unneeded", scale_down_unneeded)
        if scale_down_unready is not None:
            pulumi.set(__self__, "scale_down_unready", scale_down_unready)
        if scale_down_utilization_threshold is not None:
            pulumi.set(__self__, "scale_down_utilization_threshold", scale_down_utilization_threshold)
        if scan_interval is not None:
            pulumi.set(__self__, "scan_interval", scan_interval)
        if skip_nodes_with_local_storage is not None:
            pulumi.set(__self__, "skip_nodes_with_local_storage", skip_nodes_with_local_storage)
        if skip_nodes_with_system_pods is not None:
            pulumi.set(__self__, "skip_nodes_with_system_pods", skip_nodes_with_system_pods)

    @property
    @pulumi.getter(name="balanceSimilarNodeGroups")
    def balance_similar_node_groups(self) -> Optional[bool]:
        """
        Detect similar node groups and balance the number of nodes between them. Defaults to `false`.
        """
        return pulumi.get(self, "balance_similar_node_groups")

    @property
    @pulumi.getter(name="emptyBulkDeleteMax")
    def empty_bulk_delete_max(self) -> Optional[str]:
        """
        Maximum number of empty nodes that can be deleted at the same time. Defaults to `10`.
        """
        return pulumi.get(self, "empty_bulk_delete_max")

    @property
    @pulumi.getter
    def expander(self) -> Optional[str]:
        """
        Expander to use. Possible values are `least-waste`, `priority`, `most-pods` and `random`. Defaults to `random`.
        """
        return pulumi.get(self, "expander")

    @property
    @pulumi.getter(name="maxGracefulTerminationSec")
    def max_graceful_termination_sec(self) -> Optional[str]:
        """
        Maximum number of seconds the cluster autoscaler waits for pod termination when trying to scale down a node. Defaults to `600`.
        """
        return pulumi.get(self, "max_graceful_termination_sec")

    @property
    @pulumi.getter(name="maxNodeProvisioningTime")
    def max_node_provisioning_time(self) -> Optional[str]:
        """
        Maximum time the autoscaler waits for a node to be provisioned. Defaults to `15m`.
        """
        return pulumi.get(self, "max_node_provisioning_time")

    @property
    @pulumi.getter(name="maxUnreadyNodes")
    def max_unready_nodes(self) -> Optional[int]:
        """
        Maximum Number of allowed unready nodes. Defaults to `3`.
        """
        return pulumi.get(self, "max_unready_nodes")

    @property
    @pulumi.getter(name="maxUnreadyPercentage")
    def max_unready_percentage(self) -> Optional[float]:
        """
        Maximum percentage of unready nodes the cluster autoscaler will stop if the percentage is exceeded. Defaults to `45`.
        """
        return pulumi.get(self, "max_unready_percentage")

    @property
    @pulumi.getter(name="newPodScaleUpDelay")
    def new_pod_scale_up_delay(self) -> Optional[str]:
        """
        For scenarios like burst/batch scale where you don't want CA to act before the kubernetes scheduler could schedule all the pods, you can tell CA to ignore unscheduled pods before they're a certain age. Defaults to `10s`.
        """
        return pulumi.get(self, "new_pod_scale_up_delay")

    @property
    @pulumi.getter(name="scaleDownDelayAfterAdd")
    def scale_down_delay_after_add(self) -> Optional[str]:
        """
        How long after the scale up of AKS nodes the scale down evaluation resumes. Defaults to `10m`.
        """
        return pulumi.get(self, "scale_down_delay_after_add")

    @property
    @pulumi.getter(name="scaleDownDelayAfterDelete")
    def scale_down_delay_after_delete(self) -> Optional[str]:
        """
        How long after node deletion that scale down evaluation resumes. Defaults to the value used for `scan_interval`.
        """
        return pulumi.get(self, "scale_down_delay_after_delete")

    @property
    @pulumi.getter(name="scaleDownDelayAfterFailure")
    def scale_down_delay_after_failure(self) -> Optional[str]:
        """
        How long after scale down failure that scale down evaluation resumes. Defaults to `3m`.
        """
        return pulumi.get(self, "scale_down_delay_after_failure")

    @property
    @pulumi.getter(name="scaleDownUnneeded")
    def scale_down_unneeded(self) -> Optional[str]:
        """
        How long a node should be unneeded before it is eligible for scale down. Defaults to `10m`.
        """
        return pulumi.get(self, "scale_down_unneeded")

    @property
    @pulumi.getter(name="scaleDownUnready")
    def scale_down_unready(self) -> Optional[str]:
        """
        How long an unready node should be unneeded before it is eligible for scale down. Defaults to `20m`.
        """
        return pulumi.get(self, "scale_down_unready")

    @property
    @pulumi.getter(name="scaleDownUtilizationThreshold")
    def scale_down_utilization_threshold(self) -> Optional[str]:
        """
        Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down. Defaults to `0.5`.
        """
        return pulumi.get(self, "scale_down_utilization_threshold")

    @property
    @pulumi.getter(name="scanInterval")
    def scan_interval(self) -> Optional[str]:
        """
        How often the AKS Cluster should be re-evaluated for scale up/down. Defaults to `10s`.
        """
        return pulumi.get(self, "scan_interval")

    @property
    @pulumi.getter(name="skipNodesWithLocalStorage")
    def skip_nodes_with_local_storage(self) -> Optional[bool]:
        """
        If `true` cluster autoscaler will never delete nodes with pods with local storage, for example, EmptyDir or HostPath. Defaults to `true`.
        """
        return pulumi.get(self, "skip_nodes_with_local_storage")

    @property
    @pulumi.getter(name="skipNodesWithSystemPods")
    def skip_nodes_with_system_pods(self) -> Optional[bool]:
        """
        If `true` cluster autoscaler will never delete nodes with pods from kube-system (except for DaemonSet or mirror pods). Defaults to `true`.
        """
        return pulumi.get(self, "skip_nodes_with_system_pods")


@pulumi.output_type
class KubernetesClusterDefaultNodePool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmSize":
            suggest = "vm_size"
        elif key == "availabilityZones":
            suggest = "availability_zones"
        elif key == "enableAutoScaling":
            suggest = "enable_auto_scaling"
        elif key == "enableHostEncryption":
            suggest = "enable_host_encryption"
        elif key == "enableNodePublicIp":
            suggest = "enable_node_public_ip"
        elif key == "fipsEnabled":
            suggest = "fips_enabled"
        elif key == "kubeletConfig":
            suggest = "kubelet_config"
        elif key == "kubeletDiskType":
            suggest = "kubelet_disk_type"
        elif key == "linuxOsConfig":
            suggest = "linux_os_config"
        elif key == "maxCount":
            suggest = "max_count"
        elif key == "maxPods":
            suggest = "max_pods"
        elif key == "minCount":
            suggest = "min_count"
        elif key == "nodeCount":
            suggest = "node_count"
        elif key == "nodeLabels":
            suggest = "node_labels"
        elif key == "nodePublicIpPrefixId":
            suggest = "node_public_ip_prefix_id"
        elif key == "nodeTaints":
            suggest = "node_taints"
        elif key == "onlyCriticalAddonsEnabled":
            suggest = "only_critical_addons_enabled"
        elif key == "orchestratorVersion":
            suggest = "orchestrator_version"
        elif key == "osDiskSizeGb":
            suggest = "os_disk_size_gb"
        elif key == "osDiskType":
            suggest = "os_disk_type"
        elif key == "osSku":
            suggest = "os_sku"
        elif key == "podSubnetId":
            suggest = "pod_subnet_id"
        elif key == "proximityPlacementGroupId":
            suggest = "proximity_placement_group_id"
        elif key == "ultraSsdEnabled":
            suggest = "ultra_ssd_enabled"
        elif key == "upgradeSettings":
            suggest = "upgrade_settings"
        elif key == "vnetSubnetId":
            suggest = "vnet_subnet_id"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 vm_size: str,
                 availability_zones: Optional[Sequence[str]] = None,
                 enable_auto_scaling: Optional[bool] = None,
                 enable_host_encryption: Optional[bool] = None,
                 enable_node_public_ip: Optional[bool] = None,
                 fips_enabled: Optional[bool] = None,
                 kubelet_config: Optional['outputs.KubernetesClusterDefaultNodePoolKubeletConfig'] = None,
                 kubelet_disk_type: Optional[str] = None,
                 linux_os_config: Optional['outputs.KubernetesClusterDefaultNodePoolLinuxOsConfig'] = None,
                 max_count: Optional[int] = None,
                 max_pods: Optional[int] = None,
                 min_count: Optional[int] = None,
                 node_count: Optional[int] = None,
                 node_labels: Optional[Mapping[str, str]] = None,
                 node_public_ip_prefix_id: Optional[str] = None,
                 node_taints: Optional[Sequence[str]] = None,
                 only_critical_addons_enabled: Optional[bool] = None,
                 orchestrator_version: Optional[str] = None,
                 os_disk_size_gb: Optional[int] = None,
                 os_disk_type: Optional[str] = None,
                 os_sku: Optional[str] = None,
                 pod_subnet_id: Optional[str] = None,
                 proximity_placement_group_id: Optional[str] = None,
                 tags: Optional[Mapping[str, str]] = None,
                 type: Optional[str] = None,
                 ultra_ssd_enabled: Optional[bool] = None,
                 upgrade_settings: Optional['outputs.KubernetesClusterDefaultNodePoolUpgradeSettings'] = None,
                 vnet_subnet_id: Optional[str] = None):
        """
        :param str name: The name which should be used for the default Kubernetes Node Pool. Changing this forces a new resource to be created.
        :param str vm_size: The size of the Virtual Machine, such as `Standard_DS2_v2`.
        :param Sequence[str] availability_zones: A list of Availability Zones across which the Node Pool should be spread. Changing this forces a new resource to be created.
        :param bool enable_auto_scaling: Should [the Kubernetes Auto Scaler](https://docs.microsoft.com/en-us/azure/aks/cluster-autoscaler) be enabled for this Node Pool? Defaults to `false`.
        :param bool enable_host_encryption: Should the nodes in the Default Node Pool have host encryption enabled? Defaults to `false`.
        :param bool enable_node_public_ip: Should nodes in this Node Pool have a Public IP Address? Defaults to `false`. Changing this forces a new resource to be created.
        :param bool fips_enabled: Should the nodes in this Node Pool have Federal Information Processing Standard enabled? Changing this forces a new resource to be created.
        :param 'KubernetesClusterDefaultNodePoolKubeletConfigArgs' kubelet_config: A `kubelet_config` block as defined below.
        :param str kubelet_disk_type: The type of disk used by kubelet. At this time the only possible value is `OS`.
        :param 'KubernetesClusterDefaultNodePoolLinuxOsConfigArgs' linux_os_config: A `linux_os_config` block as defined below.
        :param int max_count: The maximum number of nodes which should exist in this Node Pool. If specified this must be between `1` and `1000`.
        :param int max_pods: The maximum number of pods that can run on each agent. Changing this forces a new resource to be created.
        :param int min_count: The minimum number of nodes which should exist in this Node Pool. If specified this must be between `1` and `1000`.
        :param int node_count: The initial number of nodes which should exist in this Node Pool. If specified this must be between `1` and `1000` and between `min_count` and `max_count`.
        :param Mapping[str, str] node_labels: A map of Kubernetes labels which should be applied to nodes in the Default Node Pool. Changing this forces a new resource to be created.
        :param str node_public_ip_prefix_id: Resource ID for the Public IP Addresses Prefix for the nodes in this Node Pool. `enable_node_public_ip` should be `true`. Changing this forces a new resource to be created.
        :param bool only_critical_addons_enabled: Enabling this option will taint default node pool with `CriticalAddonsOnly=true:NoSchedule` taint. Changing this forces a new resource to be created.
        :param str orchestrator_version: Version of Kubernetes used for the Agents. If not specified, the latest recommended version will be used at provisioning time (but won't auto-upgrade)
        :param int os_disk_size_gb: The size of the OS Disk which should be used for each agent in the Node Pool. Changing this forces a new resource to be created.
        :param str os_disk_type: The type of disk which should be used for the Operating System. Possible values are `Ephemeral` and `Managed`. Defaults to `Managed`. Changing this forces a new resource to be created.
        :param str os_sku: OsSKU to be used to specify Linux OSType. Not applicable to Windows OSType. Possible values include: `Ubuntu`, `CBLMariner`. Defaults to `Ubuntu`. Changing this forces a new resource to be created.
        :param str pod_subnet_id: The ID of the Subnet where the pods in the default Node Pool should exist. Changing this forces a new resource to be created.
        :param Mapping[str, str] tags: A mapping of tags to assign to the Node Pool.
        :param str type: The type of Node Pool which should be created. Possible values are `AvailabilitySet` and `VirtualMachineScaleSets`. Defaults to `VirtualMachineScaleSets`.
        :param bool ultra_ssd_enabled: Used to specify whether the UltraSSD is enabled in the Default Node Pool. Defaults to `false`. See [the documentation](https://docs.microsoft.com/en-us/azure/aks/use-ultra-disks) for more information.
        :param 'KubernetesClusterDefaultNodePoolUpgradeSettingsArgs' upgrade_settings: A `upgrade_settings` block as documented below.
        :param str vnet_subnet_id: The ID of a Subnet where the Kubernetes Node Pool should exist. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "vm_size", vm_size)
        if availability_zones is not None:
            pulumi.set(__self__, "availability_zones", availability_zones)
        if enable_auto_scaling is not None:
            pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
        if enable_host_encryption is not None:
            pulumi.set(__self__, "enable_host_encryption", enable_host_encryption)
        if enable_node_public_ip is not None:
            pulumi.set(__self__, "enable_node_public_ip", enable_node_public_ip)
        if fips_enabled is not None:
            pulumi.set(__self__, "fips_enabled", fips_enabled)
        if kubelet_config is not None:
            pulumi.set(__self__, "kubelet_config", kubelet_config)
        if kubelet_disk_type is not None:
            pulumi.set(__self__, "kubelet_disk_type", kubelet_disk_type)
        if linux_os_config is not None:
            pulumi.set(__self__, "linux_os_config", linux_os_config)
        if max_count is not None:
            pulumi.set(__self__, "max_count", max_count)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if node_count is not None:
            pulumi.set(__self__, "node_count", node_count)
        if node_labels is not None:
            pulumi.set(__self__, "node_labels", node_labels)
        if node_public_ip_prefix_id is not None:
            pulumi.set(__self__, "node_public_ip_prefix_id", node_public_ip_prefix_id)
        if node_taints is not None:
            pulumi.set(__self__, "node_taints", node_taints)
        if only_critical_addons_enabled is not None:
            pulumi.set(__self__, "only_critical_addons_enabled", only_critical_addons_enabled)
        if orchestrator_version is not None:
            pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if os_disk_type is not None:
            pulumi.set(__self__, "os_disk_type", os_disk_type)
        if os_sku is not None:
            pulumi.set(__self__, "os_sku", os_sku)
        if pod_subnet_id is not None:
            pulumi.set(__self__, "pod_subnet_id", pod_subnet_id)
        if proximity_placement_group_id is not None:
            pulumi.set(__self__, "proximity_placement_group_id", proximity_placement_group_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if ultra_ssd_enabled is not None:
            pulumi.set(__self__, "ultra_ssd_enabled", ultra_ssd_enabled)
        if upgrade_settings is not None:
            pulumi.set(__self__, "upgrade_settings", upgrade_settings)
        if vnet_subnet_id is not None:
            pulumi.set(__self__, "vnet_subnet_id", vnet_subnet_id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for the default Kubernetes Node Pool. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The size of the Virtual Machine, such as `Standard_DS2_v2`.
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> Optional[Sequence[str]]:
        """
        A list of Availability Zones across which the Node Pool should be spread. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "availability_zones")

    @property
    @pulumi.getter(name="enableAutoScaling")
    def enable_auto_scaling(self) -> Optional[bool]:
        """
        Should [the Kubernetes Auto Scaler](https://docs.microsoft.com/en-us/azure/aks/cluster-autoscaler) be enabled for this Node Pool? Defaults to `false`.
        """
        return pulumi.get(self, "enable_auto_scaling")

    @property
    @pulumi.getter(name="enableHostEncryption")
    def enable_host_encryption(self) -> Optional[bool]:
        """
        Should the nodes in the Default Node Pool have host encryption enabled? Defaults to `false`.
        """
        return pulumi.get(self, "enable_host_encryption")

    @property
    @pulumi.getter(name="enableNodePublicIp")
    def enable_node_public_ip(self) -> Optional[bool]:
        """
        Should nodes in this Node Pool have a Public IP Address? Defaults to `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "enable_node_public_ip")

    @property
    @pulumi.getter(name="fipsEnabled")
    def fips_enabled(self) -> Optional[bool]:
        """
        Should the nodes in this Node Pool have Federal Information Processing Standard enabled? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fips_enabled")

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

    @property
    @pulumi.getter(name="kubeletDiskType")
    def kubelet_disk_type(self) -> Optional[str]:
        """
        The type of disk used by kubelet. At this time the only possible value is `OS`.
        """
        return pulumi.get(self, "kubelet_disk_type")

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

    @property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> Optional[int]:
        """
        The maximum number of nodes which should exist in this Node Pool. If specified this must be between `1` and `1000`.
        """
        return pulumi.get(self, "max_count")

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[int]:
        """
        The maximum number of pods that can run on each agent. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "max_pods")

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> Optional[int]:
        """
        The minimum number of nodes which should exist in this Node Pool. If specified this must be between `1` and `1000`.
        """
        return pulumi.get(self, "min_count")

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[int]:
        """
        The initial number of nodes which should exist in this Node Pool. If specified this must be between `1` and `1000` and between `min_count` and `max_count`.
        """
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter(name="nodeLabels")
    def node_labels(self) -> Optional[Mapping[str, str]]:
        """
        A map of Kubernetes labels which should be applied to nodes in the Default Node Pool. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "node_labels")

    @property
    @pulumi.getter(name="nodePublicIpPrefixId")
    def node_public_ip_prefix_id(self) -> Optional[str]:
        """
        Resource ID for the Public IP Addresses Prefix for the nodes in this Node Pool. `enable_node_public_ip` should be `true`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "node_public_ip_prefix_id")

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

    @property
    @pulumi.getter(name="onlyCriticalAddonsEnabled")
    def only_critical_addons_enabled(self) -> Optional[bool]:
        """
        Enabling this option will taint default node pool with `CriticalAddonsOnly=true:NoSchedule` taint. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "only_critical_addons_enabled")

    @property
    @pulumi.getter(name="orchestratorVersion")
    def orchestrator_version(self) -> Optional[str]:
        """
        Version of Kubernetes used for the Agents. If not specified, the latest recommended version will be used at provisioning time (but won't auto-upgrade)
        """
        return pulumi.get(self, "orchestrator_version")

    @property
    @pulumi.getter(name="osDiskSizeGb")
    def os_disk_size_gb(self) -> Optional[int]:
        """
        The size of the OS Disk which should be used for each agent in the Node Pool. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "os_disk_size_gb")

    @property
    @pulumi.getter(name="osDiskType")
    def os_disk_type(self) -> Optional[str]:
        """
        The type of disk which should be used for the Operating System. Possible values are `Ephemeral` and `Managed`. Defaults to `Managed`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "os_disk_type")

    @property
    @pulumi.getter(name="osSku")
    def os_sku(self) -> Optional[str]:
        """
        OsSKU to be used to specify Linux OSType. Not applicable to Windows OSType. Possible values include: `Ubuntu`, `CBLMariner`. Defaults to `Ubuntu`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "os_sku")

    @property
    @pulumi.getter(name="podSubnetId")
    def pod_subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet where the pods in the default Node Pool should exist. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "pod_subnet_id")

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

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, str]]:
        """
        A mapping of tags to assign to the Node Pool.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of Node Pool which should be created. Possible values are `AvailabilitySet` and `VirtualMachineScaleSets`. Defaults to `VirtualMachineScaleSets`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="ultraSsdEnabled")
    def ultra_ssd_enabled(self) -> Optional[bool]:
        """
        Used to specify whether the UltraSSD is enabled in the Default Node Pool. Defaults to `false`. See [the documentation](https://docs.microsoft.com/en-us/azure/aks/use-ultra-disks) for more information.
        """
        return pulumi.get(self, "ultra_ssd_enabled")

    @property
    @pulumi.getter(name="upgradeSettings")
    def upgrade_settings(self) -> Optional['outputs.KubernetesClusterDefaultNodePoolUpgradeSettings']:
        """
        A `upgrade_settings` block as documented below.
        """
        return pulumi.get(self, "upgrade_settings")

    @property
    @pulumi.getter(name="vnetSubnetId")
    def vnet_subnet_id(self) -> Optional[str]:
        """
        The ID of a Subnet where the Kubernetes Node Pool should exist. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vnet_subnet_id")


@pulumi.output_type
class KubernetesClusterDefaultNodePoolKubeletConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedUnsafeSysctls":
            suggest = "allowed_unsafe_sysctls"
        elif key == "containerLogMaxLine":
            suggest = "container_log_max_line"
        elif key == "containerLogMaxSizeMb":
            suggest = "container_log_max_size_mb"
        elif key == "cpuCfsQuotaEnabled":
            suggest = "cpu_cfs_quota_enabled"
        elif key == "cpuCfsQuotaPeriod":
            suggest = "cpu_cfs_quota_period"
        elif key == "cpuManagerPolicy":
            suggest = "cpu_manager_policy"
        elif key == "imageGcHighThreshold":
            suggest = "image_gc_high_threshold"
        elif key == "imageGcLowThreshold":
            suggest = "image_gc_low_threshold"
        elif key == "podMaxPid":
            suggest = "pod_max_pid"
        elif key == "topologyManagerPolicy":
            suggest = "topology_manager_policy"

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

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

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

    def __init__(__self__, *,
                 allowed_unsafe_sysctls: Optional[Sequence[str]] = None,
                 container_log_max_line: Optional[int] = None,
                 container_log_max_size_mb: Optional[int] = None,
                 cpu_cfs_quota_enabled: Optional[bool] = None,
                 cpu_cfs_quota_period: Optional[str] = None,
                 cpu_manager_policy: Optional[str] = None,
                 image_gc_high_threshold: Optional[int] = None,
                 image_gc_low_threshold: Optional[int] = None,
                 pod_max_pid: Optional[int] = None,
                 topology_manager_policy: Optional[str] = None):
        """
        :param Sequence[str] allowed_unsafe_sysctls: Specifies the allow list of unsafe sysctls command or patterns (ending in `*`). Changing this forces a new resource to be created.
        :param int container_log_max_line: Specifies the maximum number of container log files that can be present for a container. must be at least 2. Changing this forces a new resource to be created.
        :param int container_log_max_size_mb: Specifies the maximum size (e.g. 10MB) of container log file before it is rotated. Changing this forces a new resource to be created.
        :param bool cpu_cfs_quota_enabled: Is CPU CFS quota enforcement for containers enabled? Changing this forces a new resource to be created.
        :param str cpu_cfs_quota_period: Specifies the CPU CFS quota period value. Changing this forces a new resource to be created.
        :param str cpu_manager_policy: Specifies the CPU Manager policy to use. Possible values are `none` and `static`, Changing this forces a new resource to be created.
        :param int image_gc_high_threshold: Specifies the percent of disk usage above which image garbage collection is always run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        :param int image_gc_low_threshold: Specifies the percent of disk usage lower than which image garbage collection is never run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        :param int pod_max_pid: Specifies the maximum number of processes per pod. Changing this forces a new resource to be created.
        :param str topology_manager_policy: Specifies the Topology Manager policy to use. Possible values are `none`, `best-effort`, `restricted` or `single-numa-node`. Changing this forces a new resource to be created.
        """
        if allowed_unsafe_sysctls is not None:
            pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
        if container_log_max_line is not None:
            pulumi.set(__self__, "container_log_max_line", container_log_max_line)
        if container_log_max_size_mb is not None:
            pulumi.set(__self__, "container_log_max_size_mb", container_log_max_size_mb)
        if cpu_cfs_quota_enabled is not None:
            pulumi.set(__self__, "cpu_cfs_quota_enabled", cpu_cfs_quota_enabled)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
        if image_gc_high_threshold is not None:
            pulumi.set(__self__, "image_gc_high_threshold", image_gc_high_threshold)
        if image_gc_low_threshold is not None:
            pulumi.set(__self__, "image_gc_low_threshold", image_gc_low_threshold)
        if pod_max_pid is not None:
            pulumi.set(__self__, "pod_max_pid", pod_max_pid)
        if topology_manager_policy is not None:
            pulumi.set(__self__, "topology_manager_policy", topology_manager_policy)

    @property
    @pulumi.getter(name="allowedUnsafeSysctls")
    def allowed_unsafe_sysctls(self) -> Optional[Sequence[str]]:
        """
        Specifies the allow list of unsafe sysctls command or patterns (ending in `*`). Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "allowed_unsafe_sysctls")

    @property
    @pulumi.getter(name="containerLogMaxLine")
    def container_log_max_line(self) -> Optional[int]:
        """
        Specifies the maximum number of container log files that can be present for a container. must be at least 2. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "container_log_max_line")

    @property
    @pulumi.getter(name="containerLogMaxSizeMb")
    def container_log_max_size_mb(self) -> Optional[int]:
        """
        Specifies the maximum size (e.g. 10MB) of container log file before it is rotated. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "container_log_max_size_mb")

    @property
    @pulumi.getter(name="cpuCfsQuotaEnabled")
    def cpu_cfs_quota_enabled(self) -> Optional[bool]:
        """
        Is CPU CFS quota enforcement for containers enabled? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu_cfs_quota_enabled")

    @property
    @pulumi.getter(name="cpuCfsQuotaPeriod")
    def cpu_cfs_quota_period(self) -> Optional[str]:
        """
        Specifies the CPU CFS quota period value. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu_cfs_quota_period")

    @property
    @pulumi.getter(name="cpuManagerPolicy")
    def cpu_manager_policy(self) -> Optional[str]:
        """
        Specifies the CPU Manager policy to use. Possible values are `none` and `static`, Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu_manager_policy")

    @property
    @pulumi.getter(name="imageGcHighThreshold")
    def image_gc_high_threshold(self) -> Optional[int]:
        """
        Specifies the percent of disk usage above which image garbage collection is always run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "image_gc_high_threshold")

    @property
    @pulumi.getter(name="imageGcLowThreshold")
    def image_gc_low_threshold(self) -> Optional[int]:
        """
        Specifies the percent of disk usage lower than which image garbage collection is never run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "image_gc_low_threshold")

    @property
    @pulumi.getter(name="podMaxPid")
    def pod_max_pid(self) -> Optional[int]:
        """
        Specifies the maximum number of processes per pod. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "pod_max_pid")

    @property
    @pulumi.getter(name="topologyManagerPolicy")
    def topology_manager_policy(self) -> Optional[str]:
        """
        Specifies the Topology Manager policy to use. Possible values are `none`, `best-effort`, `restricted` or `single-numa-node`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "topology_manager_policy")


@pulumi.output_type
class KubernetesClusterDefaultNodePoolLinuxOsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "swapFileSizeMb":
            suggest = "swap_file_size_mb"
        elif key == "sysctlConfig":
            suggest = "sysctl_config"
        elif key == "transparentHugePageDefrag":
            suggest = "transparent_huge_page_defrag"
        elif key == "transparentHugePageEnabled":
            suggest = "transparent_huge_page_enabled"

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

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

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

    def __init__(__self__, *,
                 swap_file_size_mb: Optional[int] = None,
                 sysctl_config: Optional['outputs.KubernetesClusterDefaultNodePoolLinuxOsConfigSysctlConfig'] = None,
                 transparent_huge_page_defrag: Optional[str] = None,
                 transparent_huge_page_enabled: Optional[str] = None):
        """
        :param int swap_file_size_mb: Specifies the size of swap file on each node in MB. Changing this forces a new resource to be created.
        :param 'KubernetesClusterDefaultNodePoolLinuxOsConfigSysctlConfigArgs' sysctl_config: A `sysctl_config` block as defined below. Changing this forces a new resource to be created.
        :param str transparent_huge_page_defrag: specifies the defrag configuration for Transparent Huge Page. Possible values are `always`, `defer`, `defer+madvise`, `madvise` and `never`. Changing this forces a new resource to be created.
        :param str transparent_huge_page_enabled: Specifies the Transparent Huge Page enabled configuration. Possible values are `always`, `madvise` and `never`. Changing this forces a new resource to be created.
        """
        if swap_file_size_mb is not None:
            pulumi.set(__self__, "swap_file_size_mb", swap_file_size_mb)
        if sysctl_config is not None:
            pulumi.set(__self__, "sysctl_config", sysctl_config)
        if transparent_huge_page_defrag is not None:
            pulumi.set(__self__, "transparent_huge_page_defrag", transparent_huge_page_defrag)
        if transparent_huge_page_enabled is not None:
            pulumi.set(__self__, "transparent_huge_page_enabled", transparent_huge_page_enabled)

    @property
    @pulumi.getter(name="swapFileSizeMb")
    def swap_file_size_mb(self) -> Optional[int]:
        """
        Specifies the size of swap file on each node in MB. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "swap_file_size_mb")

    @property
    @pulumi.getter(name="sysctlConfig")
    def sysctl_config(self) -> Optional['outputs.KubernetesClusterDefaultNodePoolLinuxOsConfigSysctlConfig']:
        """
        A `sysctl_config` block as defined below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "sysctl_config")

    @property
    @pulumi.getter(name="transparentHugePageDefrag")
    def transparent_huge_page_defrag(self) -> Optional[str]:
        """
        specifies the defrag configuration for Transparent Huge Page. Possible values are `always`, `defer`, `defer+madvise`, `madvise` and `never`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "transparent_huge_page_defrag")

    @property
    @pulumi.getter(name="transparentHugePageEnabled")
    def transparent_huge_page_enabled(self) -> Optional[str]:
        """
        Specifies the Transparent Huge Page enabled configuration. Possible values are `always`, `madvise` and `never`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "transparent_huge_page_enabled")


@pulumi.output_type
class KubernetesClusterDefaultNodePoolLinuxOsConfigSysctlConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fsAioMaxNr":
            suggest = "fs_aio_max_nr"
        elif key == "fsFileMax":
            suggest = "fs_file_max"
        elif key == "fsInotifyMaxUserWatches":
            suggest = "fs_inotify_max_user_watches"
        elif key == "fsNrOpen":
            suggest = "fs_nr_open"
        elif key == "kernelThreadsMax":
            suggest = "kernel_threads_max"
        elif key == "netCoreNetdevMaxBacklog":
            suggest = "net_core_netdev_max_backlog"
        elif key == "netCoreOptmemMax":
            suggest = "net_core_optmem_max"
        elif key == "netCoreRmemDefault":
            suggest = "net_core_rmem_default"
        elif key == "netCoreRmemMax":
            suggest = "net_core_rmem_max"
        elif key == "netCoreSomaxconn":
            suggest = "net_core_somaxconn"
        elif key == "netCoreWmemDefault":
            suggest = "net_core_wmem_default"
        elif key == "netCoreWmemMax":
            suggest = "net_core_wmem_max"
        elif key == "netIpv4IpLocalPortRangeMax":
            suggest = "net_ipv4_ip_local_port_range_max"
        elif key == "netIpv4IpLocalPortRangeMin":
            suggest = "net_ipv4_ip_local_port_range_min"
        elif key == "netIpv4NeighDefaultGcThresh1":
            suggest = "net_ipv4_neigh_default_gc_thresh1"
        elif key == "netIpv4NeighDefaultGcThresh2":
            suggest = "net_ipv4_neigh_default_gc_thresh2"
        elif key == "netIpv4NeighDefaultGcThresh3":
            suggest = "net_ipv4_neigh_default_gc_thresh3"
        elif key == "netIpv4TcpFinTimeout":
            suggest = "net_ipv4_tcp_fin_timeout"
        elif key == "netIpv4TcpKeepaliveIntvl":
            suggest = "net_ipv4_tcp_keepalive_intvl"
        elif key == "netIpv4TcpKeepaliveProbes":
            suggest = "net_ipv4_tcp_keepalive_probes"
        elif key == "netIpv4TcpKeepaliveTime":
            suggest = "net_ipv4_tcp_keepalive_time"
        elif key == "netIpv4TcpMaxSynBacklog":
            suggest = "net_ipv4_tcp_max_syn_backlog"
        elif key == "netIpv4TcpMaxTwBuckets":
            suggest = "net_ipv4_tcp_max_tw_buckets"
        elif key == "netIpv4TcpTwReuse":
            suggest = "net_ipv4_tcp_tw_reuse"
        elif key == "netNetfilterNfConntrackBuckets":
            suggest = "net_netfilter_nf_conntrack_buckets"
        elif key == "netNetfilterNfConntrackMax":
            suggest = "net_netfilter_nf_conntrack_max"
        elif key == "vmMaxMapCount":
            suggest = "vm_max_map_count"
        elif key == "vmSwappiness":
            suggest = "vm_swappiness"
        elif key == "vmVfsCachePressure":
            suggest = "vm_vfs_cache_pressure"

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

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

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

    def __init__(__self__, *,
                 fs_aio_max_nr: Optional[int] = None,
                 fs_file_max: Optional[int] = None,
                 fs_inotify_max_user_watches: Optional[int] = None,
                 fs_nr_open: Optional[int] = None,
                 kernel_threads_max: Optional[int] = None,
                 net_core_netdev_max_backlog: Optional[int] = None,
                 net_core_optmem_max: Optional[int] = None,
                 net_core_rmem_default: Optional[int] = None,
                 net_core_rmem_max: Optional[int] = None,
                 net_core_somaxconn: Optional[int] = None,
                 net_core_wmem_default: Optional[int] = None,
                 net_core_wmem_max: Optional[int] = None,
                 net_ipv4_ip_local_port_range_max: Optional[int] = None,
                 net_ipv4_ip_local_port_range_min: Optional[int] = None,
                 net_ipv4_neigh_default_gc_thresh1: Optional[int] = None,
                 net_ipv4_neigh_default_gc_thresh2: Optional[int] = None,
                 net_ipv4_neigh_default_gc_thresh3: Optional[int] = None,
                 net_ipv4_tcp_fin_timeout: Optional[int] = None,
                 net_ipv4_tcp_keepalive_intvl: Optional[int] = None,
                 net_ipv4_tcp_keepalive_probes: Optional[int] = None,
                 net_ipv4_tcp_keepalive_time: Optional[int] = None,
                 net_ipv4_tcp_max_syn_backlog: Optional[int] = None,
                 net_ipv4_tcp_max_tw_buckets: Optional[int] = None,
                 net_ipv4_tcp_tw_reuse: Optional[bool] = None,
                 net_netfilter_nf_conntrack_buckets: Optional[int] = None,
                 net_netfilter_nf_conntrack_max: Optional[int] = None,
                 vm_max_map_count: Optional[int] = None,
                 vm_swappiness: Optional[int] = None,
                 vm_vfs_cache_pressure: Optional[int] = None):
        """
        :param int fs_aio_max_nr: The sysctl setting fs.aio-max-nr. Must be between `65536` and `6553500`. Changing this forces a new resource to be created.
        :param int fs_file_max: The sysctl setting fs.file-max. Must be between `8192` and `12000500`. Changing this forces a new resource to be created.
        :param int fs_inotify_max_user_watches: The sysctl setting fs.inotify.max_user_watches. Must be between `781250` and `2097152`. Changing this forces a new resource to be created.
        :param int fs_nr_open: The sysctl setting fs.nr_open. Must be between `8192` and `20000500`. Changing this forces a new resource to be created.
        :param int kernel_threads_max: The sysctl setting kernel.threads-max. Must be between `20` and `513785`. Changing this forces a new resource to be created.
        :param int net_core_netdev_max_backlog: The sysctl setting net.core.netdev_max_backlog. Must be between `1000` and `3240000`. Changing this forces a new resource to be created.
        :param int net_core_optmem_max: The sysctl setting net.core.optmem_max. Must be between `20480` and `4194304`. Changing this forces a new resource to be created.
        :param int net_core_rmem_default: The sysctl setting net.core.rmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_core_rmem_max: The sysctl setting net.core.rmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_core_somaxconn: The sysctl setting net.core.somaxconn. Must be between `4096` and `3240000`. Changing this forces a new resource to be created.
        :param int net_core_wmem_default: The sysctl setting net.core.wmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_core_wmem_max: The sysctl setting net.core.wmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_ipv4_ip_local_port_range_max: The sysctl setting net.ipv4.ip_local_port_range max value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        :param int net_ipv4_ip_local_port_range_min: The sysctl setting net.ipv4.ip_local_port_range min value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        :param int net_ipv4_neigh_default_gc_thresh1: The sysctl setting net.ipv4.neigh.default.gc_thresh1. Must be between `128` and `80000`. Changing this forces a new resource to be created.
        :param int net_ipv4_neigh_default_gc_thresh2: The sysctl setting net.ipv4.neigh.default.gc_thresh2. Must be between `512` and `90000`. Changing this forces a new resource to be created.
        :param int net_ipv4_neigh_default_gc_thresh3: The sysctl setting net.ipv4.neigh.default.gc_thresh3. Must be between `1024` and `100000`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_fin_timeout: The sysctl setting net.ipv4.tcp_fin_timeout. Must be between `5` and `120`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_keepalive_intvl: The sysctl setting net.ipv4.tcp_keepalive_intvl. Must be between `10` and `75`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_keepalive_probes: The sysctl setting net.ipv4.tcp_keepalive_probes. Must be between `1` and `15`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_keepalive_time: The sysctl setting net.ipv4.tcp_keepalive_time. Must be between `30` and `432000`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_max_syn_backlog: The sysctl setting net.ipv4.tcp_max_syn_backlog. Must be between `128` and `3240000`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_max_tw_buckets: The sysctl setting net.ipv4.tcp_max_tw_buckets. Must be between `8000` and `1440000`. Changing this forces a new resource to be created.
        :param bool net_ipv4_tcp_tw_reuse: The sysctl setting net.ipv4.tcp_tw_reuse. Changing this forces a new resource to be created.
        :param int net_netfilter_nf_conntrack_buckets: The sysctl setting net.netfilter.nf_conntrack_buckets. Must be between `65536` and `147456`. Changing this forces a new resource to be created.
        :param int net_netfilter_nf_conntrack_max: The sysctl setting net.netfilter.nf_conntrack_max. Must be between `131072` and `589824`. Changing this forces a new resource to be created.
        :param int vm_max_map_count: The sysctl setting vm.max_map_count. Must be between `65530` and `262144`. Changing this forces a new resource to be created.
        :param int vm_swappiness: The sysctl setting vm.swappiness. Must be between `0` and `100`. Changing this forces a new resource to be created.
        :param int vm_vfs_cache_pressure: The sysctl setting vm.vfs_cache_pressure. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        if fs_aio_max_nr is not None:
            pulumi.set(__self__, "fs_aio_max_nr", fs_aio_max_nr)
        if fs_file_max is not None:
            pulumi.set(__self__, "fs_file_max", fs_file_max)
        if fs_inotify_max_user_watches is not None:
            pulumi.set(__self__, "fs_inotify_max_user_watches", fs_inotify_max_user_watches)
        if fs_nr_open is not None:
            pulumi.set(__self__, "fs_nr_open", fs_nr_open)
        if kernel_threads_max is not None:
            pulumi.set(__self__, "kernel_threads_max", kernel_threads_max)
        if net_core_netdev_max_backlog is not None:
            pulumi.set(__self__, "net_core_netdev_max_backlog", net_core_netdev_max_backlog)
        if net_core_optmem_max is not None:
            pulumi.set(__self__, "net_core_optmem_max", net_core_optmem_max)
        if net_core_rmem_default is not None:
            pulumi.set(__self__, "net_core_rmem_default", net_core_rmem_default)
        if net_core_rmem_max is not None:
            pulumi.set(__self__, "net_core_rmem_max", net_core_rmem_max)
        if net_core_somaxconn is not None:
            pulumi.set(__self__, "net_core_somaxconn", net_core_somaxconn)
        if net_core_wmem_default is not None:
            pulumi.set(__self__, "net_core_wmem_default", net_core_wmem_default)
        if net_core_wmem_max is not None:
            pulumi.set(__self__, "net_core_wmem_max", net_core_wmem_max)
        if net_ipv4_ip_local_port_range_max is not None:
            pulumi.set(__self__, "net_ipv4_ip_local_port_range_max", net_ipv4_ip_local_port_range_max)
        if net_ipv4_ip_local_port_range_min is not None:
            pulumi.set(__self__, "net_ipv4_ip_local_port_range_min", net_ipv4_ip_local_port_range_min)
        if net_ipv4_neigh_default_gc_thresh1 is not None:
            pulumi.set(__self__, "net_ipv4_neigh_default_gc_thresh1", net_ipv4_neigh_default_gc_thresh1)
        if net_ipv4_neigh_default_gc_thresh2 is not None:
            pulumi.set(__self__, "net_ipv4_neigh_default_gc_thresh2", net_ipv4_neigh_default_gc_thresh2)
        if net_ipv4_neigh_default_gc_thresh3 is not None:
            pulumi.set(__self__, "net_ipv4_neigh_default_gc_thresh3", net_ipv4_neigh_default_gc_thresh3)
        if net_ipv4_tcp_fin_timeout is not None:
            pulumi.set(__self__, "net_ipv4_tcp_fin_timeout", net_ipv4_tcp_fin_timeout)
        if net_ipv4_tcp_keepalive_intvl is not None:
            pulumi.set(__self__, "net_ipv4_tcp_keepalive_intvl", net_ipv4_tcp_keepalive_intvl)
        if net_ipv4_tcp_keepalive_probes is not None:
            pulumi.set(__self__, "net_ipv4_tcp_keepalive_probes", net_ipv4_tcp_keepalive_probes)
        if net_ipv4_tcp_keepalive_time is not None:
            pulumi.set(__self__, "net_ipv4_tcp_keepalive_time", net_ipv4_tcp_keepalive_time)
        if net_ipv4_tcp_max_syn_backlog is not None:
            pulumi.set(__self__, "net_ipv4_tcp_max_syn_backlog", net_ipv4_tcp_max_syn_backlog)
        if net_ipv4_tcp_max_tw_buckets is not None:
            pulumi.set(__self__, "net_ipv4_tcp_max_tw_buckets", net_ipv4_tcp_max_tw_buckets)
        if net_ipv4_tcp_tw_reuse is not None:
            pulumi.set(__self__, "net_ipv4_tcp_tw_reuse", net_ipv4_tcp_tw_reuse)
        if net_netfilter_nf_conntrack_buckets is not None:
            pulumi.set(__self__, "net_netfilter_nf_conntrack_buckets", net_netfilter_nf_conntrack_buckets)
        if net_netfilter_nf_conntrack_max is not None:
            pulumi.set(__self__, "net_netfilter_nf_conntrack_max", net_netfilter_nf_conntrack_max)
        if vm_max_map_count is not None:
            pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
        if vm_swappiness is not None:
            pulumi.set(__self__, "vm_swappiness", vm_swappiness)
        if vm_vfs_cache_pressure is not None:
            pulumi.set(__self__, "vm_vfs_cache_pressure", vm_vfs_cache_pressure)

    @property
    @pulumi.getter(name="fsAioMaxNr")
    def fs_aio_max_nr(self) -> Optional[int]:
        """
        The sysctl setting fs.aio-max-nr. Must be between `65536` and `6553500`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_aio_max_nr")

    @property
    @pulumi.getter(name="fsFileMax")
    def fs_file_max(self) -> Optional[int]:
        """
        The sysctl setting fs.file-max. Must be between `8192` and `12000500`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_file_max")

    @property
    @pulumi.getter(name="fsInotifyMaxUserWatches")
    def fs_inotify_max_user_watches(self) -> Optional[int]:
        """
        The sysctl setting fs.inotify.max_user_watches. Must be between `781250` and `2097152`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_inotify_max_user_watches")

    @property
    @pulumi.getter(name="fsNrOpen")
    def fs_nr_open(self) -> Optional[int]:
        """
        The sysctl setting fs.nr_open. Must be between `8192` and `20000500`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_nr_open")

    @property
    @pulumi.getter(name="kernelThreadsMax")
    def kernel_threads_max(self) -> Optional[int]:
        """
        The sysctl setting kernel.threads-max. Must be between `20` and `513785`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "kernel_threads_max")

    @property
    @pulumi.getter(name="netCoreNetdevMaxBacklog")
    def net_core_netdev_max_backlog(self) -> Optional[int]:
        """
        The sysctl setting net.core.netdev_max_backlog. Must be between `1000` and `3240000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_netdev_max_backlog")

    @property
    @pulumi.getter(name="netCoreOptmemMax")
    def net_core_optmem_max(self) -> Optional[int]:
        """
        The sysctl setting net.core.optmem_max. Must be between `20480` and `4194304`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_optmem_max")

    @property
    @pulumi.getter(name="netCoreRmemDefault")
    def net_core_rmem_default(self) -> Optional[int]:
        """
        The sysctl setting net.core.rmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_rmem_default")

    @property
    @pulumi.getter(name="netCoreRmemMax")
    def net_core_rmem_max(self) -> Optional[int]:
        """
        The sysctl setting net.core.rmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_rmem_max")

    @property
    @pulumi.getter(name="netCoreSomaxconn")
    def net_core_somaxconn(self) -> Optional[int]:
        """
        The sysctl setting net.core.somaxconn. Must be between `4096` and `3240000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_somaxconn")

    @property
    @pulumi.getter(name="netCoreWmemDefault")
    def net_core_wmem_default(self) -> Optional[int]:
        """
        The sysctl setting net.core.wmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_wmem_default")

    @property
    @pulumi.getter(name="netCoreWmemMax")
    def net_core_wmem_max(self) -> Optional[int]:
        """
        The sysctl setting net.core.wmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_wmem_max")

    @property
    @pulumi.getter(name="netIpv4IpLocalPortRangeMax")
    def net_ipv4_ip_local_port_range_max(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.ip_local_port_range max value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_ip_local_port_range_max")

    @property
    @pulumi.getter(name="netIpv4IpLocalPortRangeMin")
    def net_ipv4_ip_local_port_range_min(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.ip_local_port_range min value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_ip_local_port_range_min")

    @property
    @pulumi.getter(name="netIpv4NeighDefaultGcThresh1")
    def net_ipv4_neigh_default_gc_thresh1(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.neigh.default.gc_thresh1. Must be between `128` and `80000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_neigh_default_gc_thresh1")

    @property
    @pulumi.getter(name="netIpv4NeighDefaultGcThresh2")
    def net_ipv4_neigh_default_gc_thresh2(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.neigh.default.gc_thresh2. Must be between `512` and `90000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_neigh_default_gc_thresh2")

    @property
    @pulumi.getter(name="netIpv4NeighDefaultGcThresh3")
    def net_ipv4_neigh_default_gc_thresh3(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.neigh.default.gc_thresh3. Must be between `1024` and `100000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_neigh_default_gc_thresh3")

    @property
    @pulumi.getter(name="netIpv4TcpFinTimeout")
    def net_ipv4_tcp_fin_timeout(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_fin_timeout. Must be between `5` and `120`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_fin_timeout")

    @property
    @pulumi.getter(name="netIpv4TcpKeepaliveIntvl")
    def net_ipv4_tcp_keepalive_intvl(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_keepalive_intvl. Must be between `10` and `75`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_keepalive_intvl")

    @property
    @pulumi.getter(name="netIpv4TcpKeepaliveProbes")
    def net_ipv4_tcp_keepalive_probes(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_keepalive_probes. Must be between `1` and `15`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_keepalive_probes")

    @property
    @pulumi.getter(name="netIpv4TcpKeepaliveTime")
    def net_ipv4_tcp_keepalive_time(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_keepalive_time. Must be between `30` and `432000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_keepalive_time")

    @property
    @pulumi.getter(name="netIpv4TcpMaxSynBacklog")
    def net_ipv4_tcp_max_syn_backlog(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_max_syn_backlog. Must be between `128` and `3240000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_max_syn_backlog")

    @property
    @pulumi.getter(name="netIpv4TcpMaxTwBuckets")
    def net_ipv4_tcp_max_tw_buckets(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_max_tw_buckets. Must be between `8000` and `1440000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_max_tw_buckets")

    @property
    @pulumi.getter(name="netIpv4TcpTwReuse")
    def net_ipv4_tcp_tw_reuse(self) -> Optional[bool]:
        """
        The sysctl setting net.ipv4.tcp_tw_reuse. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_tw_reuse")

    @property
    @pulumi.getter(name="netNetfilterNfConntrackBuckets")
    def net_netfilter_nf_conntrack_buckets(self) -> Optional[int]:
        """
        The sysctl setting net.netfilter.nf_conntrack_buckets. Must be between `65536` and `147456`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_netfilter_nf_conntrack_buckets")

    @property
    @pulumi.getter(name="netNetfilterNfConntrackMax")
    def net_netfilter_nf_conntrack_max(self) -> Optional[int]:
        """
        The sysctl setting net.netfilter.nf_conntrack_max. Must be between `131072` and `589824`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_netfilter_nf_conntrack_max")

    @property
    @pulumi.getter(name="vmMaxMapCount")
    def vm_max_map_count(self) -> Optional[int]:
        """
        The sysctl setting vm.max_map_count. Must be between `65530` and `262144`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_max_map_count")

    @property
    @pulumi.getter(name="vmSwappiness")
    def vm_swappiness(self) -> Optional[int]:
        """
        The sysctl setting vm.swappiness. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_swappiness")

    @property
    @pulumi.getter(name="vmVfsCachePressure")
    def vm_vfs_cache_pressure(self) -> Optional[int]:
        """
        The sysctl setting vm.vfs_cache_pressure. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_vfs_cache_pressure")


@pulumi.output_type
class KubernetesClusterDefaultNodePoolUpgradeSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"

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

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

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

    def __init__(__self__, *,
                 max_surge: str):
        """
        :param str max_surge: The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        pulumi.set(__self__, "max_surge", max_surge)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> str:
        """
        The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        return pulumi.get(self, "max_surge")


@pulumi.output_type
class KubernetesClusterHttpProxyConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpProxy":
            suggest = "http_proxy"
        elif key == "httpsProxy":
            suggest = "https_proxy"
        elif key == "noProxies":
            suggest = "no_proxies"
        elif key == "trustedCa":
            suggest = "trusted_ca"

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

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

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

    def __init__(__self__, *,
                 http_proxy: Optional[str] = None,
                 https_proxy: Optional[str] = None,
                 no_proxies: Optional[Sequence[str]] = None,
                 trusted_ca: Optional[str] = None):
        """
        :param str http_proxy: The proxy address to be used when communicating over HTTP.
        :param str https_proxy: The proxy address to be used when communicating over HTTPS.
        :param Sequence[str] no_proxies: The list of domains that will not use the proxy for communication.
        :param str trusted_ca: The base64 encoded alternative CA certificate content in PEM format.
        """
        if http_proxy is not None:
            pulumi.set(__self__, "http_proxy", http_proxy)
        if https_proxy is not None:
            pulumi.set(__self__, "https_proxy", https_proxy)
        if no_proxies is not None:
            pulumi.set(__self__, "no_proxies", no_proxies)
        if trusted_ca is not None:
            pulumi.set(__self__, "trusted_ca", trusted_ca)

    @property
    @pulumi.getter(name="httpProxy")
    def http_proxy(self) -> Optional[str]:
        """
        The proxy address to be used when communicating over HTTP.
        """
        return pulumi.get(self, "http_proxy")

    @property
    @pulumi.getter(name="httpsProxy")
    def https_proxy(self) -> Optional[str]:
        """
        The proxy address to be used when communicating over HTTPS.
        """
        return pulumi.get(self, "https_proxy")

    @property
    @pulumi.getter(name="noProxies")
    def no_proxies(self) -> Optional[Sequence[str]]:
        """
        The list of domains that will not use the proxy for communication.
        """
        return pulumi.get(self, "no_proxies")

    @property
    @pulumi.getter(name="trustedCa")
    def trusted_ca(self) -> Optional[str]:
        """
        The base64 encoded alternative CA certificate content in PEM format.
        """
        return pulumi.get(self, "trusted_ca")


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

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

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

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

    def __init__(__self__, *,
                 type: str,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param str type: The type of identity used for the managed cluster. Possible values are `SystemAssigned` and `UserAssigned`. If `UserAssigned` is set, a `user_assigned_identity_id` must be set as well.
        :param str principal_id: The principal id of the system assigned identity which is used by main components.
        :param str tenant_id: The Tenant ID used for Azure Active Directory Application. If this isn't specified the Tenant ID of the current Subscription is used.
        :param str user_assigned_identity_id: The ID of a user assigned identity.
        """
        pulumi.set(__self__, "type", type)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of identity used for the managed cluster. Possible values are `SystemAssigned` and `UserAssigned`. If `UserAssigned` is set, a `user_assigned_identity_id` must be set as well.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[str]:
        """
        The principal id of the system assigned identity which is used by main components.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        The Tenant ID used for Azure Active Directory Application. If this isn't specified the Tenant ID of the current Subscription is used.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[str]:
        """
        The ID of a user assigned identity.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class KubernetesClusterKubeAdminConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCertificate":
            suggest = "client_certificate"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "clusterCaCertificate":
            suggest = "cluster_ca_certificate"

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

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

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

    def __init__(__self__, *,
                 client_certificate: Optional[str] = None,
                 client_key: Optional[str] = None,
                 cluster_ca_certificate: Optional[str] = None,
                 host: Optional[str] = None,
                 password: Optional[str] = None,
                 username: Optional[str] = None):
        """
        :param str client_certificate: Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        :param str client_key: Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        :param str cluster_ca_certificate: Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        :param str host: The Kubernetes cluster server host.
        :param str password: A password or token used to authenticate to the Kubernetes cluster.
        :param str username: A username used to authenticate to the Kubernetes cluster.
        """
        if client_certificate is not None:
            pulumi.set(__self__, "client_certificate", client_certificate)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="clientCertificate")
    def client_certificate(self) -> Optional[str]:
        """
        Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_certificate")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        """
        Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clusterCaCertificate")
    def cluster_ca_certificate(self) -> Optional[str]:
        """
        Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        """
        return pulumi.get(self, "cluster_ca_certificate")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        The Kubernetes cluster server host.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        A password or token used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        A username used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class KubernetesClusterKubeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCertificate":
            suggest = "client_certificate"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "clusterCaCertificate":
            suggest = "cluster_ca_certificate"

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

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

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

    def __init__(__self__, *,
                 client_certificate: Optional[str] = None,
                 client_key: Optional[str] = None,
                 cluster_ca_certificate: Optional[str] = None,
                 host: Optional[str] = None,
                 password: Optional[str] = None,
                 username: Optional[str] = None):
        """
        :param str client_certificate: Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        :param str client_key: Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        :param str cluster_ca_certificate: Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        :param str host: The Kubernetes cluster server host.
        :param str password: A password or token used to authenticate to the Kubernetes cluster.
        :param str username: A username used to authenticate to the Kubernetes cluster.
        """
        if client_certificate is not None:
            pulumi.set(__self__, "client_certificate", client_certificate)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="clientCertificate")
    def client_certificate(self) -> Optional[str]:
        """
        Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_certificate")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        """
        Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clusterCaCertificate")
    def cluster_ca_certificate(self) -> Optional[str]:
        """
        Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        """
        return pulumi.get(self, "cluster_ca_certificate")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        The Kubernetes cluster server host.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        A password or token used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        A username used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class KubernetesClusterKubeletIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "objectId":
            suggest = "object_id"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 object_id: Optional[str] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        :param str user_assigned_identity_id: The ID of the User Assigned Identity assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if object_id is not None:
            pulumi.set(__self__, "object_id", object_id)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        The Client ID of the user-defined Managed Identity to be assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> Optional[str]:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[str]:
        """
        The ID of the User Assigned Identity assigned to the Kubelets. If not specified a Managed Identity is created automatically.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class KubernetesClusterLinuxProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adminUsername":
            suggest = "admin_username"
        elif key == "sshKey":
            suggest = "ssh_key"

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

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

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

    def __init__(__self__, *,
                 admin_username: str,
                 ssh_key: 'outputs.KubernetesClusterLinuxProfileSshKey'):
        """
        :param str admin_username: The Admin Username for the Cluster. Changing this forces a new resource to be created.
        :param 'KubernetesClusterLinuxProfileSshKeyArgs' ssh_key: An `ssh_key` block. Only one is currently allowed. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "admin_username", admin_username)
        pulumi.set(__self__, "ssh_key", ssh_key)

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> str:
        """
        The Admin Username for the Cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "admin_username")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> 'outputs.KubernetesClusterLinuxProfileSshKey':
        """
        An `ssh_key` block. Only one is currently allowed. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "ssh_key")


@pulumi.output_type
class KubernetesClusterLinuxProfileSshKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyData":
            suggest = "key_data"

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

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

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

    def __init__(__self__, *,
                 key_data: str):
        """
        :param str key_data: The Public SSH Key used to access the cluster. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "key_data", key_data)

    @property
    @pulumi.getter(name="keyData")
    def key_data(self) -> str:
        """
        The Public SSH Key used to access the cluster. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "key_data")


@pulumi.output_type
class KubernetesClusterMaintenanceWindow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notAlloweds":
            suggest = "not_alloweds"

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

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

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

    def __init__(__self__, *,
                 alloweds: Optional[Sequence['outputs.KubernetesClusterMaintenanceWindowAllowed']] = None,
                 not_alloweds: Optional[Sequence['outputs.KubernetesClusterMaintenanceWindowNotAllowed']] = None):
        """
        :param Sequence['KubernetesClusterMaintenanceWindowAllowedArgs'] alloweds: One or more `allowed` block as defined below.
        :param Sequence['KubernetesClusterMaintenanceWindowNotAllowedArgs'] not_alloweds: One or more `not_allowed` block as defined below.
        """
        if alloweds is not None:
            pulumi.set(__self__, "alloweds", alloweds)
        if not_alloweds is not None:
            pulumi.set(__self__, "not_alloweds", not_alloweds)

    @property
    @pulumi.getter
    def alloweds(self) -> Optional[Sequence['outputs.KubernetesClusterMaintenanceWindowAllowed']]:
        """
        One or more `allowed` block as defined below.
        """
        return pulumi.get(self, "alloweds")

    @property
    @pulumi.getter(name="notAlloweds")
    def not_alloweds(self) -> Optional[Sequence['outputs.KubernetesClusterMaintenanceWindowNotAllowed']]:
        """
        One or more `not_allowed` block as defined below.
        """
        return pulumi.get(self, "not_alloweds")


@pulumi.output_type
class KubernetesClusterMaintenanceWindowAllowed(dict):
    def __init__(__self__, *,
                 day: str,
                 hours: Sequence[int]):
        """
        :param str day: A day in a week. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
        :param Sequence[int] hours: An array of hour slots in a day. Possible values are between `0` and `23`.
        """
        pulumi.set(__self__, "day", day)
        pulumi.set(__self__, "hours", hours)

    @property
    @pulumi.getter
    def day(self) -> str:
        """
        A day in a week. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
        """
        return pulumi.get(self, "day")

    @property
    @pulumi.getter
    def hours(self) -> Sequence[int]:
        """
        An array of hour slots in a day. Possible values are between `0` and `23`.
        """
        return pulumi.get(self, "hours")


@pulumi.output_type
class KubernetesClusterMaintenanceWindowNotAllowed(dict):
    def __init__(__self__, *,
                 end: str,
                 start: str):
        """
        :param str end: The end of a time span, formatted as an RFC3339 string.
        :param str start: The start of a time span, formatted as an RFC3339 string.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> str:
        """
        The end of a time span, formatted as an RFC3339 string.
        """
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> str:
        """
        The start of a time span, formatted as an RFC3339 string.
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class KubernetesClusterNetworkProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkPlugin":
            suggest = "network_plugin"
        elif key == "dnsServiceIp":
            suggest = "dns_service_ip"
        elif key == "dockerBridgeCidr":
            suggest = "docker_bridge_cidr"
        elif key == "loadBalancerProfile":
            suggest = "load_balancer_profile"
        elif key == "loadBalancerSku":
            suggest = "load_balancer_sku"
        elif key == "natGatewayProfile":
            suggest = "nat_gateway_profile"
        elif key == "networkMode":
            suggest = "network_mode"
        elif key == "networkPolicy":
            suggest = "network_policy"
        elif key == "outboundType":
            suggest = "outbound_type"
        elif key == "podCidr":
            suggest = "pod_cidr"
        elif key == "serviceCidr":
            suggest = "service_cidr"

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

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

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

    def __init__(__self__, *,
                 network_plugin: str,
                 dns_service_ip: Optional[str] = None,
                 docker_bridge_cidr: Optional[str] = None,
                 load_balancer_profile: Optional['outputs.KubernetesClusterNetworkProfileLoadBalancerProfile'] = None,
                 load_balancer_sku: Optional[str] = None,
                 nat_gateway_profile: Optional['outputs.KubernetesClusterNetworkProfileNatGatewayProfile'] = None,
                 network_mode: Optional[str] = None,
                 network_policy: Optional[str] = None,
                 outbound_type: Optional[str] = None,
                 pod_cidr: Optional[str] = None,
                 service_cidr: Optional[str] = None):
        """
        :param str network_plugin: Network plugin to use for networking. Currently supported values are `azure` and `kubenet`. Changing this forces a new resource to be created.
        :param str dns_service_ip: IP address within the Kubernetes service address range that will be used by cluster service discovery (kube-dns). Changing this forces a new resource to be created.
        :param str docker_bridge_cidr: IP address (in CIDR notation) used as the Docker bridge IP address on nodes. Changing this forces a new resource to be created.
        :param 'KubernetesClusterNetworkProfileLoadBalancerProfileArgs' load_balancer_profile: A `load_balancer_profile` block. This can only be specified when `load_balancer_sku` is set to `Standard`.
        :param str load_balancer_sku: Specifies the SKU of the Load Balancer used for this Kubernetes Cluster. Possible values are `Basic` and `Standard`. Defaults to `Standard`.
        :param 'KubernetesClusterNetworkProfileNatGatewayProfileArgs' nat_gateway_profile: A `nat_gateway_profile` block. This can only be specified when `load_balancer_sku` is set to `Standard` and `outbound_type` is set to `managedNATGateway` or `userAssignedNATGateway`.
        :param str network_mode: Network mode to be used with Azure CNI. Possible values are `bridge` and `transparent`. Changing this forces a new resource to be created.
        :param str network_policy: Sets up network policy to be used with Azure CNI. [Network policy allows us to control the traffic flow between pods](https://docs.microsoft.com/en-us/azure/aks/use-network-policies). Currently supported values are `calico` and `azure`. Changing this forces a new resource to be created.
        :param str outbound_type: The outbound (egress) routing method which should be used for this Kubernetes Cluster. Possible values are `loadBalancer`, `userDefinedRouting`, `managedNATGateway` and `userAssignedNATGateway`. Defaults to `loadBalancer`.
        :param str pod_cidr: The CIDR to use for pod IP addresses. This field can only be set when `network_plugin` is set to `kubenet`. Changing this forces a new resource to be created.
        :param str service_cidr: The Network Range used by the Kubernetes service. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "network_plugin", network_plugin)
        if dns_service_ip is not None:
            pulumi.set(__self__, "dns_service_ip", dns_service_ip)
        if docker_bridge_cidr is not None:
            pulumi.set(__self__, "docker_bridge_cidr", docker_bridge_cidr)
        if load_balancer_profile is not None:
            pulumi.set(__self__, "load_balancer_profile", load_balancer_profile)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if nat_gateway_profile is not None:
            pulumi.set(__self__, "nat_gateway_profile", nat_gateway_profile)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if outbound_type is not None:
            pulumi.set(__self__, "outbound_type", outbound_type)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> str:
        """
        Network plugin to use for networking. Currently supported values are `azure` and `kubenet`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "network_plugin")

    @property
    @pulumi.getter(name="dnsServiceIp")
    def dns_service_ip(self) -> Optional[str]:
        """
        IP address within the Kubernetes service address range that will be used by cluster service discovery (kube-dns). Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "dns_service_ip")

    @property
    @pulumi.getter(name="dockerBridgeCidr")
    def docker_bridge_cidr(self) -> Optional[str]:
        """
        IP address (in CIDR notation) used as the Docker bridge IP address on nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "docker_bridge_cidr")

    @property
    @pulumi.getter(name="loadBalancerProfile")
    def load_balancer_profile(self) -> Optional['outputs.KubernetesClusterNetworkProfileLoadBalancerProfile']:
        """
        A `load_balancer_profile` block. This can only be specified when `load_balancer_sku` is set to `Standard`.
        """
        return pulumi.get(self, "load_balancer_profile")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        Specifies the SKU of the Load Balancer used for this Kubernetes Cluster. Possible values are `Basic` and `Standard`. Defaults to `Standard`.
        """
        return pulumi.get(self, "load_balancer_sku")

    @property
    @pulumi.getter(name="natGatewayProfile")
    def nat_gateway_profile(self) -> Optional['outputs.KubernetesClusterNetworkProfileNatGatewayProfile']:
        """
        A `nat_gateway_profile` block. This can only be specified when `load_balancer_sku` is set to `Standard` and `outbound_type` is set to `managedNATGateway` or `userAssignedNATGateway`.
        """
        return pulumi.get(self, "nat_gateway_profile")

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> Optional[str]:
        """
        Network mode to be used with Azure CNI. Possible values are `bridge` and `transparent`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "network_mode")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> Optional[str]:
        """
        Sets up network policy to be used with Azure CNI. [Network policy allows us to control the traffic flow between pods](https://docs.microsoft.com/en-us/azure/aks/use-network-policies). Currently supported values are `calico` and `azure`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="outboundType")
    def outbound_type(self) -> Optional[str]:
        """
        The outbound (egress) routing method which should be used for this Kubernetes Cluster. Possible values are `loadBalancer`, `userDefinedRouting`, `managedNATGateway` and `userAssignedNATGateway`. Defaults to `loadBalancer`.
        """
        return pulumi.get(self, "outbound_type")

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[str]:
        """
        The CIDR to use for pod IP addresses. This field can only be set when `network_plugin` is set to `kubenet`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "pod_cidr")

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[str]:
        """
        The Network Range used by the Kubernetes service. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "service_cidr")


@pulumi.output_type
class KubernetesClusterNetworkProfileLoadBalancerProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "effectiveOutboundIps":
            suggest = "effective_outbound_ips"
        elif key == "idleTimeoutInMinutes":
            suggest = "idle_timeout_in_minutes"
        elif key == "managedOutboundIpCount":
            suggest = "managed_outbound_ip_count"
        elif key == "outboundIpAddressIds":
            suggest = "outbound_ip_address_ids"
        elif key == "outboundIpPrefixIds":
            suggest = "outbound_ip_prefix_ids"
        elif key == "outboundPortsAllocated":
            suggest = "outbound_ports_allocated"

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

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

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

    def __init__(__self__, *,
                 effective_outbound_ips: Optional[Sequence[str]] = None,
                 idle_timeout_in_minutes: Optional[int] = None,
                 managed_outbound_ip_count: Optional[int] = None,
                 outbound_ip_address_ids: Optional[Sequence[str]] = None,
                 outbound_ip_prefix_ids: Optional[Sequence[str]] = None,
                 outbound_ports_allocated: Optional[int] = None):
        """
        :param Sequence[str] effective_outbound_ips: The outcome (resource IDs) of the specified arguments.
        :param int idle_timeout_in_minutes: Desired outbound flow idle timeout in minutes for the cluster load balancer. Must be between `4` and `120` inclusive. Defaults to `30`.
        :param int managed_outbound_ip_count: Count of desired managed outbound IPs for the cluster load balancer. Must be between `1` and `100` inclusive.
        :param Sequence[str] outbound_ip_address_ids: The ID of the Public IP Addresses which should be used for outbound communication for the cluster load balancer.
        :param Sequence[str] outbound_ip_prefix_ids: The ID of the outbound Public IP Address Prefixes which should be used for the cluster load balancer.
        :param int outbound_ports_allocated: Number of desired SNAT port for each VM in the clusters load balancer. Must be between `0` and `64000` inclusive. Defaults to `0`.
        """
        if effective_outbound_ips is not None:
            pulumi.set(__self__, "effective_outbound_ips", effective_outbound_ips)
        if idle_timeout_in_minutes is not None:
            pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
        if managed_outbound_ip_count is not None:
            pulumi.set(__self__, "managed_outbound_ip_count", managed_outbound_ip_count)
        if outbound_ip_address_ids is not None:
            pulumi.set(__self__, "outbound_ip_address_ids", outbound_ip_address_ids)
        if outbound_ip_prefix_ids is not None:
            pulumi.set(__self__, "outbound_ip_prefix_ids", outbound_ip_prefix_ids)
        if outbound_ports_allocated is not None:
            pulumi.set(__self__, "outbound_ports_allocated", outbound_ports_allocated)

    @property
    @pulumi.getter(name="effectiveOutboundIps")
    def effective_outbound_ips(self) -> Optional[Sequence[str]]:
        """
        The outcome (resource IDs) of the specified arguments.
        """
        return pulumi.get(self, "effective_outbound_ips")

    @property
    @pulumi.getter(name="idleTimeoutInMinutes")
    def idle_timeout_in_minutes(self) -> Optional[int]:
        """
        Desired outbound flow idle timeout in minutes for the cluster load balancer. Must be between `4` and `120` inclusive. Defaults to `30`.
        """
        return pulumi.get(self, "idle_timeout_in_minutes")

    @property
    @pulumi.getter(name="managedOutboundIpCount")
    def managed_outbound_ip_count(self) -> Optional[int]:
        """
        Count of desired managed outbound IPs for the cluster load balancer. Must be between `1` and `100` inclusive.
        """
        return pulumi.get(self, "managed_outbound_ip_count")

    @property
    @pulumi.getter(name="outboundIpAddressIds")
    def outbound_ip_address_ids(self) -> Optional[Sequence[str]]:
        """
        The ID of the Public IP Addresses which should be used for outbound communication for the cluster load balancer.
        """
        return pulumi.get(self, "outbound_ip_address_ids")

    @property
    @pulumi.getter(name="outboundIpPrefixIds")
    def outbound_ip_prefix_ids(self) -> Optional[Sequence[str]]:
        """
        The ID of the outbound Public IP Address Prefixes which should be used for the cluster load balancer.
        """
        return pulumi.get(self, "outbound_ip_prefix_ids")

    @property
    @pulumi.getter(name="outboundPortsAllocated")
    def outbound_ports_allocated(self) -> Optional[int]:
        """
        Number of desired SNAT port for each VM in the clusters load balancer. Must be between `0` and `64000` inclusive. Defaults to `0`.
        """
        return pulumi.get(self, "outbound_ports_allocated")


@pulumi.output_type
class KubernetesClusterNetworkProfileNatGatewayProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "effectiveOutboundIps":
            suggest = "effective_outbound_ips"
        elif key == "idleTimeoutInMinutes":
            suggest = "idle_timeout_in_minutes"
        elif key == "managedOutboundIpCount":
            suggest = "managed_outbound_ip_count"

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

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

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

    def __init__(__self__, *,
                 effective_outbound_ips: Optional[Sequence[str]] = None,
                 idle_timeout_in_minutes: Optional[int] = None,
                 managed_outbound_ip_count: Optional[int] = None):
        """
        :param Sequence[str] effective_outbound_ips: The outcome (resource IDs) of the specified arguments.
        :param int idle_timeout_in_minutes: Desired outbound flow idle timeout in minutes for the cluster load balancer. Must be between `4` and `120` inclusive. Defaults to `4`.
        :param int managed_outbound_ip_count: Count of desired managed outbound IPs for the cluster load balancer. Must be between `1` and `100` inclusive.
        """
        if effective_outbound_ips is not None:
            pulumi.set(__self__, "effective_outbound_ips", effective_outbound_ips)
        if idle_timeout_in_minutes is not None:
            pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
        if managed_outbound_ip_count is not None:
            pulumi.set(__self__, "managed_outbound_ip_count", managed_outbound_ip_count)

    @property
    @pulumi.getter(name="effectiveOutboundIps")
    def effective_outbound_ips(self) -> Optional[Sequence[str]]:
        """
        The outcome (resource IDs) of the specified arguments.
        """
        return pulumi.get(self, "effective_outbound_ips")

    @property
    @pulumi.getter(name="idleTimeoutInMinutes")
    def idle_timeout_in_minutes(self) -> Optional[int]:
        """
        Desired outbound flow idle timeout in minutes for the cluster load balancer. Must be between `4` and `120` inclusive. Defaults to `4`.
        """
        return pulumi.get(self, "idle_timeout_in_minutes")

    @property
    @pulumi.getter(name="managedOutboundIpCount")
    def managed_outbound_ip_count(self) -> Optional[int]:
        """
        Count of desired managed outbound IPs for the cluster load balancer. Must be between `1` and `100` inclusive.
        """
        return pulumi.get(self, "managed_outbound_ip_count")


@pulumi.output_type
class KubernetesClusterNodePoolKubeletConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedUnsafeSysctls":
            suggest = "allowed_unsafe_sysctls"
        elif key == "containerLogMaxLine":
            suggest = "container_log_max_line"
        elif key == "containerLogMaxSizeMb":
            suggest = "container_log_max_size_mb"
        elif key == "cpuCfsQuotaEnabled":
            suggest = "cpu_cfs_quota_enabled"
        elif key == "cpuCfsQuotaPeriod":
            suggest = "cpu_cfs_quota_period"
        elif key == "cpuManagerPolicy":
            suggest = "cpu_manager_policy"
        elif key == "imageGcHighThreshold":
            suggest = "image_gc_high_threshold"
        elif key == "imageGcLowThreshold":
            suggest = "image_gc_low_threshold"
        elif key == "podMaxPid":
            suggest = "pod_max_pid"
        elif key == "topologyManagerPolicy":
            suggest = "topology_manager_policy"

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

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

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

    def __init__(__self__, *,
                 allowed_unsafe_sysctls: Optional[Sequence[str]] = None,
                 container_log_max_line: Optional[int] = None,
                 container_log_max_size_mb: Optional[int] = None,
                 cpu_cfs_quota_enabled: Optional[bool] = None,
                 cpu_cfs_quota_period: Optional[str] = None,
                 cpu_manager_policy: Optional[str] = None,
                 image_gc_high_threshold: Optional[int] = None,
                 image_gc_low_threshold: Optional[int] = None,
                 pod_max_pid: Optional[int] = None,
                 topology_manager_policy: Optional[str] = None):
        """
        :param Sequence[str] allowed_unsafe_sysctls: Specifies the allow list of unsafe sysctls command or patterns (ending in `*`). Changing this forces a new resource to be created.
        :param int container_log_max_line: Specifies the maximum number of container log files that can be present for a container. must be at least 2. Changing this forces a new resource to be created.
        :param int container_log_max_size_mb: Specifies the maximum size (e.g. 10MB) of container log file before it is rotated. Changing this forces a new resource to be created.
        :param bool cpu_cfs_quota_enabled: Is CPU CFS quota enforcement for containers enabled? Changing this forces a new resource to be created.
        :param str cpu_cfs_quota_period: Specifies the CPU CFS quota period value. Changing this forces a new resource to be created.
        :param str cpu_manager_policy: Specifies the CPU Manager policy to use. Possible values are `none` and `static`, Changing this forces a new resource to be created.
        :param int image_gc_high_threshold: Specifies the percent of disk usage above which image garbage collection is always run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        :param int image_gc_low_threshold: Specifies the percent of disk usage lower than which image garbage collection is never run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        :param int pod_max_pid: Specifies the maximum number of processes per pod. Changing this forces a new resource to be created.
        :param str topology_manager_policy: Specifies the Topology Manager policy to use. Possible values are `none`, `best-effort`, `restricted` or `single-numa-node`. Changing this forces a new resource to be created.
        """
        if allowed_unsafe_sysctls is not None:
            pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
        if container_log_max_line is not None:
            pulumi.set(__self__, "container_log_max_line", container_log_max_line)
        if container_log_max_size_mb is not None:
            pulumi.set(__self__, "container_log_max_size_mb", container_log_max_size_mb)
        if cpu_cfs_quota_enabled is not None:
            pulumi.set(__self__, "cpu_cfs_quota_enabled", cpu_cfs_quota_enabled)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
        if image_gc_high_threshold is not None:
            pulumi.set(__self__, "image_gc_high_threshold", image_gc_high_threshold)
        if image_gc_low_threshold is not None:
            pulumi.set(__self__, "image_gc_low_threshold", image_gc_low_threshold)
        if pod_max_pid is not None:
            pulumi.set(__self__, "pod_max_pid", pod_max_pid)
        if topology_manager_policy is not None:
            pulumi.set(__self__, "topology_manager_policy", topology_manager_policy)

    @property
    @pulumi.getter(name="allowedUnsafeSysctls")
    def allowed_unsafe_sysctls(self) -> Optional[Sequence[str]]:
        """
        Specifies the allow list of unsafe sysctls command or patterns (ending in `*`). Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "allowed_unsafe_sysctls")

    @property
    @pulumi.getter(name="containerLogMaxLine")
    def container_log_max_line(self) -> Optional[int]:
        """
        Specifies the maximum number of container log files that can be present for a container. must be at least 2. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "container_log_max_line")

    @property
    @pulumi.getter(name="containerLogMaxSizeMb")
    def container_log_max_size_mb(self) -> Optional[int]:
        """
        Specifies the maximum size (e.g. 10MB) of container log file before it is rotated. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "container_log_max_size_mb")

    @property
    @pulumi.getter(name="cpuCfsQuotaEnabled")
    def cpu_cfs_quota_enabled(self) -> Optional[bool]:
        """
        Is CPU CFS quota enforcement for containers enabled? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu_cfs_quota_enabled")

    @property
    @pulumi.getter(name="cpuCfsQuotaPeriod")
    def cpu_cfs_quota_period(self) -> Optional[str]:
        """
        Specifies the CPU CFS quota period value. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu_cfs_quota_period")

    @property
    @pulumi.getter(name="cpuManagerPolicy")
    def cpu_manager_policy(self) -> Optional[str]:
        """
        Specifies the CPU Manager policy to use. Possible values are `none` and `static`, Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cpu_manager_policy")

    @property
    @pulumi.getter(name="imageGcHighThreshold")
    def image_gc_high_threshold(self) -> Optional[int]:
        """
        Specifies the percent of disk usage above which image garbage collection is always run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "image_gc_high_threshold")

    @property
    @pulumi.getter(name="imageGcLowThreshold")
    def image_gc_low_threshold(self) -> Optional[int]:
        """
        Specifies the percent of disk usage lower than which image garbage collection is never run. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "image_gc_low_threshold")

    @property
    @pulumi.getter(name="podMaxPid")
    def pod_max_pid(self) -> Optional[int]:
        """
        Specifies the maximum number of processes per pod. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "pod_max_pid")

    @property
    @pulumi.getter(name="topologyManagerPolicy")
    def topology_manager_policy(self) -> Optional[str]:
        """
        Specifies the Topology Manager policy to use. Possible values are `none`, `best-effort`, `restricted` or `single-numa-node`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "topology_manager_policy")


@pulumi.output_type
class KubernetesClusterNodePoolLinuxOsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "swapFileSizeMb":
            suggest = "swap_file_size_mb"
        elif key == "sysctlConfig":
            suggest = "sysctl_config"
        elif key == "transparentHugePageDefrag":
            suggest = "transparent_huge_page_defrag"
        elif key == "transparentHugePageEnabled":
            suggest = "transparent_huge_page_enabled"

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

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

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

    def __init__(__self__, *,
                 swap_file_size_mb: Optional[int] = None,
                 sysctl_config: Optional['outputs.KubernetesClusterNodePoolLinuxOsConfigSysctlConfig'] = None,
                 transparent_huge_page_defrag: Optional[str] = None,
                 transparent_huge_page_enabled: Optional[str] = None):
        """
        :param int swap_file_size_mb: Specifies the size of swap file on each node in MB. Changing this forces a new resource to be created.
        :param 'KubernetesClusterNodePoolLinuxOsConfigSysctlConfigArgs' sysctl_config: A `sysctl_config` block as defined below. Changing this forces a new resource to be created.
        :param str transparent_huge_page_defrag: specifies the defrag configuration for Transparent Huge Page. Possible values are `always`, `defer`, `defer+madvise`, `madvise` and `never`. Changing this forces a new resource to be created.
        :param str transparent_huge_page_enabled: Specifies the Transparent Huge Page enabled configuration. Possible values are `always`, `madvise` and `never`. Changing this forces a new resource to be created.
        """
        if swap_file_size_mb is not None:
            pulumi.set(__self__, "swap_file_size_mb", swap_file_size_mb)
        if sysctl_config is not None:
            pulumi.set(__self__, "sysctl_config", sysctl_config)
        if transparent_huge_page_defrag is not None:
            pulumi.set(__self__, "transparent_huge_page_defrag", transparent_huge_page_defrag)
        if transparent_huge_page_enabled is not None:
            pulumi.set(__self__, "transparent_huge_page_enabled", transparent_huge_page_enabled)

    @property
    @pulumi.getter(name="swapFileSizeMb")
    def swap_file_size_mb(self) -> Optional[int]:
        """
        Specifies the size of swap file on each node in MB. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "swap_file_size_mb")

    @property
    @pulumi.getter(name="sysctlConfig")
    def sysctl_config(self) -> Optional['outputs.KubernetesClusterNodePoolLinuxOsConfigSysctlConfig']:
        """
        A `sysctl_config` block as defined below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "sysctl_config")

    @property
    @pulumi.getter(name="transparentHugePageDefrag")
    def transparent_huge_page_defrag(self) -> Optional[str]:
        """
        specifies the defrag configuration for Transparent Huge Page. Possible values are `always`, `defer`, `defer+madvise`, `madvise` and `never`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "transparent_huge_page_defrag")

    @property
    @pulumi.getter(name="transparentHugePageEnabled")
    def transparent_huge_page_enabled(self) -> Optional[str]:
        """
        Specifies the Transparent Huge Page enabled configuration. Possible values are `always`, `madvise` and `never`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "transparent_huge_page_enabled")


@pulumi.output_type
class KubernetesClusterNodePoolLinuxOsConfigSysctlConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fsAioMaxNr":
            suggest = "fs_aio_max_nr"
        elif key == "fsFileMax":
            suggest = "fs_file_max"
        elif key == "fsInotifyMaxUserWatches":
            suggest = "fs_inotify_max_user_watches"
        elif key == "fsNrOpen":
            suggest = "fs_nr_open"
        elif key == "kernelThreadsMax":
            suggest = "kernel_threads_max"
        elif key == "netCoreNetdevMaxBacklog":
            suggest = "net_core_netdev_max_backlog"
        elif key == "netCoreOptmemMax":
            suggest = "net_core_optmem_max"
        elif key == "netCoreRmemDefault":
            suggest = "net_core_rmem_default"
        elif key == "netCoreRmemMax":
            suggest = "net_core_rmem_max"
        elif key == "netCoreSomaxconn":
            suggest = "net_core_somaxconn"
        elif key == "netCoreWmemDefault":
            suggest = "net_core_wmem_default"
        elif key == "netCoreWmemMax":
            suggest = "net_core_wmem_max"
        elif key == "netIpv4IpLocalPortRangeMax":
            suggest = "net_ipv4_ip_local_port_range_max"
        elif key == "netIpv4IpLocalPortRangeMin":
            suggest = "net_ipv4_ip_local_port_range_min"
        elif key == "netIpv4NeighDefaultGcThresh1":
            suggest = "net_ipv4_neigh_default_gc_thresh1"
        elif key == "netIpv4NeighDefaultGcThresh2":
            suggest = "net_ipv4_neigh_default_gc_thresh2"
        elif key == "netIpv4NeighDefaultGcThresh3":
            suggest = "net_ipv4_neigh_default_gc_thresh3"
        elif key == "netIpv4TcpFinTimeout":
            suggest = "net_ipv4_tcp_fin_timeout"
        elif key == "netIpv4TcpKeepaliveIntvl":
            suggest = "net_ipv4_tcp_keepalive_intvl"
        elif key == "netIpv4TcpKeepaliveProbes":
            suggest = "net_ipv4_tcp_keepalive_probes"
        elif key == "netIpv4TcpKeepaliveTime":
            suggest = "net_ipv4_tcp_keepalive_time"
        elif key == "netIpv4TcpMaxSynBacklog":
            suggest = "net_ipv4_tcp_max_syn_backlog"
        elif key == "netIpv4TcpMaxTwBuckets":
            suggest = "net_ipv4_tcp_max_tw_buckets"
        elif key == "netIpv4TcpTwReuse":
            suggest = "net_ipv4_tcp_tw_reuse"
        elif key == "netNetfilterNfConntrackBuckets":
            suggest = "net_netfilter_nf_conntrack_buckets"
        elif key == "netNetfilterNfConntrackMax":
            suggest = "net_netfilter_nf_conntrack_max"
        elif key == "vmMaxMapCount":
            suggest = "vm_max_map_count"
        elif key == "vmSwappiness":
            suggest = "vm_swappiness"
        elif key == "vmVfsCachePressure":
            suggest = "vm_vfs_cache_pressure"

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

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

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

    def __init__(__self__, *,
                 fs_aio_max_nr: Optional[int] = None,
                 fs_file_max: Optional[int] = None,
                 fs_inotify_max_user_watches: Optional[int] = None,
                 fs_nr_open: Optional[int] = None,
                 kernel_threads_max: Optional[int] = None,
                 net_core_netdev_max_backlog: Optional[int] = None,
                 net_core_optmem_max: Optional[int] = None,
                 net_core_rmem_default: Optional[int] = None,
                 net_core_rmem_max: Optional[int] = None,
                 net_core_somaxconn: Optional[int] = None,
                 net_core_wmem_default: Optional[int] = None,
                 net_core_wmem_max: Optional[int] = None,
                 net_ipv4_ip_local_port_range_max: Optional[int] = None,
                 net_ipv4_ip_local_port_range_min: Optional[int] = None,
                 net_ipv4_neigh_default_gc_thresh1: Optional[int] = None,
                 net_ipv4_neigh_default_gc_thresh2: Optional[int] = None,
                 net_ipv4_neigh_default_gc_thresh3: Optional[int] = None,
                 net_ipv4_tcp_fin_timeout: Optional[int] = None,
                 net_ipv4_tcp_keepalive_intvl: Optional[int] = None,
                 net_ipv4_tcp_keepalive_probes: Optional[int] = None,
                 net_ipv4_tcp_keepalive_time: Optional[int] = None,
                 net_ipv4_tcp_max_syn_backlog: Optional[int] = None,
                 net_ipv4_tcp_max_tw_buckets: Optional[int] = None,
                 net_ipv4_tcp_tw_reuse: Optional[bool] = None,
                 net_netfilter_nf_conntrack_buckets: Optional[int] = None,
                 net_netfilter_nf_conntrack_max: Optional[int] = None,
                 vm_max_map_count: Optional[int] = None,
                 vm_swappiness: Optional[int] = None,
                 vm_vfs_cache_pressure: Optional[int] = None):
        """
        :param int fs_aio_max_nr: The sysctl setting fs.aio-max-nr. Must be between `65536` and `6553500`. Changing this forces a new resource to be created.
        :param int fs_file_max: The sysctl setting fs.file-max. Must be between `8192` and `12000500`. Changing this forces a new resource to be created.
        :param int fs_inotify_max_user_watches: The sysctl setting fs.inotify.max_user_watches. Must be between `781250` and `2097152`. Changing this forces a new resource to be created.
        :param int fs_nr_open: The sysctl setting fs.nr_open. Must be between `8192` and `20000500`. Changing this forces a new resource to be created.
        :param int kernel_threads_max: The sysctl setting kernel.threads-max. Must be between `20` and `513785`. Changing this forces a new resource to be created.
        :param int net_core_netdev_max_backlog: The sysctl setting net.core.netdev_max_backlog. Must be between `1000` and `3240000`. Changing this forces a new resource to be created.
        :param int net_core_optmem_max: The sysctl setting net.core.optmem_max. Must be between `20480` and `4194304`. Changing this forces a new resource to be created.
        :param int net_core_rmem_default: The sysctl setting net.core.rmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_core_rmem_max: The sysctl setting net.core.rmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_core_somaxconn: The sysctl setting net.core.somaxconn. Must be between `4096` and `3240000`. Changing this forces a new resource to be created.
        :param int net_core_wmem_default: The sysctl setting net.core.wmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_core_wmem_max: The sysctl setting net.core.wmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        :param int net_ipv4_ip_local_port_range_max: The sysctl setting net.ipv4.ip_local_port_range max value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        :param int net_ipv4_ip_local_port_range_min: The sysctl setting net.ipv4.ip_local_port_range min value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        :param int net_ipv4_neigh_default_gc_thresh1: The sysctl setting net.ipv4.neigh.default.gc_thresh1. Must be between `128` and `80000`. Changing this forces a new resource to be created.
        :param int net_ipv4_neigh_default_gc_thresh2: The sysctl setting net.ipv4.neigh.default.gc_thresh2. Must be between `512` and `90000`. Changing this forces a new resource to be created.
        :param int net_ipv4_neigh_default_gc_thresh3: The sysctl setting net.ipv4.neigh.default.gc_thresh3. Must be between `1024` and `100000`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_fin_timeout: The sysctl setting net.ipv4.tcp_fin_timeout. Must be between `5` and `120`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_keepalive_intvl: The sysctl setting net.ipv4.tcp_keepalive_intvl. Must be between `10` and `75`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_keepalive_probes: The sysctl setting net.ipv4.tcp_keepalive_probes. Must be between `1` and `15`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_keepalive_time: The sysctl setting net.ipv4.tcp_keepalive_time. Must be between `30` and `432000`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_max_syn_backlog: The sysctl setting net.ipv4.tcp_max_syn_backlog. Must be between `128` and `3240000`. Changing this forces a new resource to be created.
        :param int net_ipv4_tcp_max_tw_buckets: The sysctl setting net.ipv4.tcp_max_tw_buckets. Must be between `8000` and `1440000`. Changing this forces a new resource to be created.
        :param bool net_ipv4_tcp_tw_reuse: Is sysctl setting net.ipv4.tcp_tw_reuse enabled? Changing this forces a new resource to be created.
        :param int net_netfilter_nf_conntrack_buckets: The sysctl setting net.netfilter.nf_conntrack_buckets. Must be between `65536` and `147456`. Changing this forces a new resource to be created.
        :param int net_netfilter_nf_conntrack_max: The sysctl setting net.netfilter.nf_conntrack_max. Must be between `131072` and `589824`. Changing this forces a new resource to be created.
        :param int vm_max_map_count: The sysctl setting vm.max_map_count. Must be between `65530` and `262144`. Changing this forces a new resource to be created.
        :param int vm_swappiness: The sysctl setting vm.swappiness. Must be between `0` and `100`. Changing this forces a new resource to be created.
        :param int vm_vfs_cache_pressure: The sysctl setting vm.vfs_cache_pressure. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        if fs_aio_max_nr is not None:
            pulumi.set(__self__, "fs_aio_max_nr", fs_aio_max_nr)
        if fs_file_max is not None:
            pulumi.set(__self__, "fs_file_max", fs_file_max)
        if fs_inotify_max_user_watches is not None:
            pulumi.set(__self__, "fs_inotify_max_user_watches", fs_inotify_max_user_watches)
        if fs_nr_open is not None:
            pulumi.set(__self__, "fs_nr_open", fs_nr_open)
        if kernel_threads_max is not None:
            pulumi.set(__self__, "kernel_threads_max", kernel_threads_max)
        if net_core_netdev_max_backlog is not None:
            pulumi.set(__self__, "net_core_netdev_max_backlog", net_core_netdev_max_backlog)
        if net_core_optmem_max is not None:
            pulumi.set(__self__, "net_core_optmem_max", net_core_optmem_max)
        if net_core_rmem_default is not None:
            pulumi.set(__self__, "net_core_rmem_default", net_core_rmem_default)
        if net_core_rmem_max is not None:
            pulumi.set(__self__, "net_core_rmem_max", net_core_rmem_max)
        if net_core_somaxconn is not None:
            pulumi.set(__self__, "net_core_somaxconn", net_core_somaxconn)
        if net_core_wmem_default is not None:
            pulumi.set(__self__, "net_core_wmem_default", net_core_wmem_default)
        if net_core_wmem_max is not None:
            pulumi.set(__self__, "net_core_wmem_max", net_core_wmem_max)
        if net_ipv4_ip_local_port_range_max is not None:
            pulumi.set(__self__, "net_ipv4_ip_local_port_range_max", net_ipv4_ip_local_port_range_max)
        if net_ipv4_ip_local_port_range_min is not None:
            pulumi.set(__self__, "net_ipv4_ip_local_port_range_min", net_ipv4_ip_local_port_range_min)
        if net_ipv4_neigh_default_gc_thresh1 is not None:
            pulumi.set(__self__, "net_ipv4_neigh_default_gc_thresh1", net_ipv4_neigh_default_gc_thresh1)
        if net_ipv4_neigh_default_gc_thresh2 is not None:
            pulumi.set(__self__, "net_ipv4_neigh_default_gc_thresh2", net_ipv4_neigh_default_gc_thresh2)
        if net_ipv4_neigh_default_gc_thresh3 is not None:
            pulumi.set(__self__, "net_ipv4_neigh_default_gc_thresh3", net_ipv4_neigh_default_gc_thresh3)
        if net_ipv4_tcp_fin_timeout is not None:
            pulumi.set(__self__, "net_ipv4_tcp_fin_timeout", net_ipv4_tcp_fin_timeout)
        if net_ipv4_tcp_keepalive_intvl is not None:
            pulumi.set(__self__, "net_ipv4_tcp_keepalive_intvl", net_ipv4_tcp_keepalive_intvl)
        if net_ipv4_tcp_keepalive_probes is not None:
            pulumi.set(__self__, "net_ipv4_tcp_keepalive_probes", net_ipv4_tcp_keepalive_probes)
        if net_ipv4_tcp_keepalive_time is not None:
            pulumi.set(__self__, "net_ipv4_tcp_keepalive_time", net_ipv4_tcp_keepalive_time)
        if net_ipv4_tcp_max_syn_backlog is not None:
            pulumi.set(__self__, "net_ipv4_tcp_max_syn_backlog", net_ipv4_tcp_max_syn_backlog)
        if net_ipv4_tcp_max_tw_buckets is not None:
            pulumi.set(__self__, "net_ipv4_tcp_max_tw_buckets", net_ipv4_tcp_max_tw_buckets)
        if net_ipv4_tcp_tw_reuse is not None:
            pulumi.set(__self__, "net_ipv4_tcp_tw_reuse", net_ipv4_tcp_tw_reuse)
        if net_netfilter_nf_conntrack_buckets is not None:
            pulumi.set(__self__, "net_netfilter_nf_conntrack_buckets", net_netfilter_nf_conntrack_buckets)
        if net_netfilter_nf_conntrack_max is not None:
            pulumi.set(__self__, "net_netfilter_nf_conntrack_max", net_netfilter_nf_conntrack_max)
        if vm_max_map_count is not None:
            pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
        if vm_swappiness is not None:
            pulumi.set(__self__, "vm_swappiness", vm_swappiness)
        if vm_vfs_cache_pressure is not None:
            pulumi.set(__self__, "vm_vfs_cache_pressure", vm_vfs_cache_pressure)

    @property
    @pulumi.getter(name="fsAioMaxNr")
    def fs_aio_max_nr(self) -> Optional[int]:
        """
        The sysctl setting fs.aio-max-nr. Must be between `65536` and `6553500`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_aio_max_nr")

    @property
    @pulumi.getter(name="fsFileMax")
    def fs_file_max(self) -> Optional[int]:
        """
        The sysctl setting fs.file-max. Must be between `8192` and `12000500`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_file_max")

    @property
    @pulumi.getter(name="fsInotifyMaxUserWatches")
    def fs_inotify_max_user_watches(self) -> Optional[int]:
        """
        The sysctl setting fs.inotify.max_user_watches. Must be between `781250` and `2097152`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_inotify_max_user_watches")

    @property
    @pulumi.getter(name="fsNrOpen")
    def fs_nr_open(self) -> Optional[int]:
        """
        The sysctl setting fs.nr_open. Must be between `8192` and `20000500`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "fs_nr_open")

    @property
    @pulumi.getter(name="kernelThreadsMax")
    def kernel_threads_max(self) -> Optional[int]:
        """
        The sysctl setting kernel.threads-max. Must be between `20` and `513785`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "kernel_threads_max")

    @property
    @pulumi.getter(name="netCoreNetdevMaxBacklog")
    def net_core_netdev_max_backlog(self) -> Optional[int]:
        """
        The sysctl setting net.core.netdev_max_backlog. Must be between `1000` and `3240000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_netdev_max_backlog")

    @property
    @pulumi.getter(name="netCoreOptmemMax")
    def net_core_optmem_max(self) -> Optional[int]:
        """
        The sysctl setting net.core.optmem_max. Must be between `20480` and `4194304`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_optmem_max")

    @property
    @pulumi.getter(name="netCoreRmemDefault")
    def net_core_rmem_default(self) -> Optional[int]:
        """
        The sysctl setting net.core.rmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_rmem_default")

    @property
    @pulumi.getter(name="netCoreRmemMax")
    def net_core_rmem_max(self) -> Optional[int]:
        """
        The sysctl setting net.core.rmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_rmem_max")

    @property
    @pulumi.getter(name="netCoreSomaxconn")
    def net_core_somaxconn(self) -> Optional[int]:
        """
        The sysctl setting net.core.somaxconn. Must be between `4096` and `3240000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_somaxconn")

    @property
    @pulumi.getter(name="netCoreWmemDefault")
    def net_core_wmem_default(self) -> Optional[int]:
        """
        The sysctl setting net.core.wmem_default. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_wmem_default")

    @property
    @pulumi.getter(name="netCoreWmemMax")
    def net_core_wmem_max(self) -> Optional[int]:
        """
        The sysctl setting net.core.wmem_max. Must be between `212992` and `134217728`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_core_wmem_max")

    @property
    @pulumi.getter(name="netIpv4IpLocalPortRangeMax")
    def net_ipv4_ip_local_port_range_max(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.ip_local_port_range max value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_ip_local_port_range_max")

    @property
    @pulumi.getter(name="netIpv4IpLocalPortRangeMin")
    def net_ipv4_ip_local_port_range_min(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.ip_local_port_range min value. Must be between `1024` and `60999`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_ip_local_port_range_min")

    @property
    @pulumi.getter(name="netIpv4NeighDefaultGcThresh1")
    def net_ipv4_neigh_default_gc_thresh1(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.neigh.default.gc_thresh1. Must be between `128` and `80000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_neigh_default_gc_thresh1")

    @property
    @pulumi.getter(name="netIpv4NeighDefaultGcThresh2")
    def net_ipv4_neigh_default_gc_thresh2(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.neigh.default.gc_thresh2. Must be between `512` and `90000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_neigh_default_gc_thresh2")

    @property
    @pulumi.getter(name="netIpv4NeighDefaultGcThresh3")
    def net_ipv4_neigh_default_gc_thresh3(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.neigh.default.gc_thresh3. Must be between `1024` and `100000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_neigh_default_gc_thresh3")

    @property
    @pulumi.getter(name="netIpv4TcpFinTimeout")
    def net_ipv4_tcp_fin_timeout(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_fin_timeout. Must be between `5` and `120`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_fin_timeout")

    @property
    @pulumi.getter(name="netIpv4TcpKeepaliveIntvl")
    def net_ipv4_tcp_keepalive_intvl(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_keepalive_intvl. Must be between `10` and `75`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_keepalive_intvl")

    @property
    @pulumi.getter(name="netIpv4TcpKeepaliveProbes")
    def net_ipv4_tcp_keepalive_probes(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_keepalive_probes. Must be between `1` and `15`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_keepalive_probes")

    @property
    @pulumi.getter(name="netIpv4TcpKeepaliveTime")
    def net_ipv4_tcp_keepalive_time(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_keepalive_time. Must be between `30` and `432000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_keepalive_time")

    @property
    @pulumi.getter(name="netIpv4TcpMaxSynBacklog")
    def net_ipv4_tcp_max_syn_backlog(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_max_syn_backlog. Must be between `128` and `3240000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_max_syn_backlog")

    @property
    @pulumi.getter(name="netIpv4TcpMaxTwBuckets")
    def net_ipv4_tcp_max_tw_buckets(self) -> Optional[int]:
        """
        The sysctl setting net.ipv4.tcp_max_tw_buckets. Must be between `8000` and `1440000`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_max_tw_buckets")

    @property
    @pulumi.getter(name="netIpv4TcpTwReuse")
    def net_ipv4_tcp_tw_reuse(self) -> Optional[bool]:
        """
        Is sysctl setting net.ipv4.tcp_tw_reuse enabled? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_ipv4_tcp_tw_reuse")

    @property
    @pulumi.getter(name="netNetfilterNfConntrackBuckets")
    def net_netfilter_nf_conntrack_buckets(self) -> Optional[int]:
        """
        The sysctl setting net.netfilter.nf_conntrack_buckets. Must be between `65536` and `147456`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_netfilter_nf_conntrack_buckets")

    @property
    @pulumi.getter(name="netNetfilterNfConntrackMax")
    def net_netfilter_nf_conntrack_max(self) -> Optional[int]:
        """
        The sysctl setting net.netfilter.nf_conntrack_max. Must be between `131072` and `589824`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "net_netfilter_nf_conntrack_max")

    @property
    @pulumi.getter(name="vmMaxMapCount")
    def vm_max_map_count(self) -> Optional[int]:
        """
        The sysctl setting vm.max_map_count. Must be between `65530` and `262144`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_max_map_count")

    @property
    @pulumi.getter(name="vmSwappiness")
    def vm_swappiness(self) -> Optional[int]:
        """
        The sysctl setting vm.swappiness. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_swappiness")

    @property
    @pulumi.getter(name="vmVfsCachePressure")
    def vm_vfs_cache_pressure(self) -> Optional[int]:
        """
        The sysctl setting vm.vfs_cache_pressure. Must be between `0` and `100`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vm_vfs_cache_pressure")


@pulumi.output_type
class KubernetesClusterNodePoolUpgradeSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"

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

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

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

    def __init__(__self__, *,
                 max_surge: str):
        """
        :param str max_surge: The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        pulumi.set(__self__, "max_surge", max_surge)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> str:
        """
        The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        return pulumi.get(self, "max_surge")


@pulumi.output_type
class KubernetesClusterRoleBasedAccessControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "azureActiveDirectory":
            suggest = "azure_active_directory"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 azure_active_directory: Optional['outputs.KubernetesClusterRoleBasedAccessControlAzureActiveDirectory'] = None):
        """
        :param bool enabled: Is Role Based Access Control Enabled? Changing this forces a new resource to be created.
        :param 'KubernetesClusterRoleBasedAccessControlAzureActiveDirectoryArgs' azure_active_directory: An `azure_active_directory` block.
        """
        pulumi.set(__self__, "enabled", enabled)
        if azure_active_directory is not None:
            pulumi.set(__self__, "azure_active_directory", azure_active_directory)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control Enabled? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="azureActiveDirectory")
    def azure_active_directory(self) -> Optional['outputs.KubernetesClusterRoleBasedAccessControlAzureActiveDirectory']:
        """
        An `azure_active_directory` block.
        """
        return pulumi.get(self, "azure_active_directory")


@pulumi.output_type
class KubernetesClusterRoleBasedAccessControlAzureActiveDirectory(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adminGroupObjectIds":
            suggest = "admin_group_object_ids"
        elif key == "azureRbacEnabled":
            suggest = "azure_rbac_enabled"
        elif key == "clientAppId":
            suggest = "client_app_id"
        elif key == "serverAppId":
            suggest = "server_app_id"
        elif key == "serverAppSecret":
            suggest = "server_app_secret"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 admin_group_object_ids: Optional[Sequence[str]] = None,
                 azure_rbac_enabled: Optional[bool] = None,
                 client_app_id: Optional[str] = None,
                 managed: Optional[bool] = None,
                 server_app_id: Optional[str] = None,
                 server_app_secret: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param Sequence[str] admin_group_object_ids: A list of Object IDs of Azure Active Directory Groups which should have Admin Role on the Cluster.
        :param bool azure_rbac_enabled: Is Role Based Access Control based on Azure AD enabled?
        :param str client_app_id: The Client ID of an Azure Active Directory Application.
        :param bool managed: Is the Azure Active Directory integration Managed, meaning that Azure will create/manage the Service Principal used for integration.
        :param str server_app_id: The Server ID of an Azure Active Directory Application.
        :param str server_app_secret: The Server Secret of an Azure Active Directory Application.
        :param str tenant_id: The Tenant ID used for Azure Active Directory Application. If this isn't specified the Tenant ID of the current Subscription is used.
        """
        if admin_group_object_ids is not None:
            pulumi.set(__self__, "admin_group_object_ids", admin_group_object_ids)
        if azure_rbac_enabled is not None:
            pulumi.set(__self__, "azure_rbac_enabled", azure_rbac_enabled)
        if client_app_id is not None:
            pulumi.set(__self__, "client_app_id", client_app_id)
        if managed is not None:
            pulumi.set(__self__, "managed", managed)
        if server_app_id is not None:
            pulumi.set(__self__, "server_app_id", server_app_id)
        if server_app_secret is not None:
            pulumi.set(__self__, "server_app_secret", server_app_secret)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="adminGroupObjectIds")
    def admin_group_object_ids(self) -> Optional[Sequence[str]]:
        """
        A list of Object IDs of Azure Active Directory Groups which should have Admin Role on the Cluster.
        """
        return pulumi.get(self, "admin_group_object_ids")

    @property
    @pulumi.getter(name="azureRbacEnabled")
    def azure_rbac_enabled(self) -> Optional[bool]:
        """
        Is Role Based Access Control based on Azure AD enabled?
        """
        return pulumi.get(self, "azure_rbac_enabled")

    @property
    @pulumi.getter(name="clientAppId")
    def client_app_id(self) -> Optional[str]:
        """
        The Client ID of an Azure Active Directory Application.
        """
        return pulumi.get(self, "client_app_id")

    @property
    @pulumi.getter
    def managed(self) -> Optional[bool]:
        """
        Is the Azure Active Directory integration Managed, meaning that Azure will create/manage the Service Principal used for integration.
        """
        return pulumi.get(self, "managed")

    @property
    @pulumi.getter(name="serverAppId")
    def server_app_id(self) -> Optional[str]:
        """
        The Server ID of an Azure Active Directory Application.
        """
        return pulumi.get(self, "server_app_id")

    @property
    @pulumi.getter(name="serverAppSecret")
    def server_app_secret(self) -> Optional[str]:
        """
        The Server Secret of an Azure Active Directory Application.
        """
        return pulumi.get(self, "server_app_secret")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        The Tenant ID used for Azure Active Directory Application. If this isn't specified the Tenant ID of the current Subscription is used.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class KubernetesClusterServicePrincipal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"

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

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

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

    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str):
        """
        :param str client_id: The Client ID for the Service Principal.
        :param str client_secret: The Client Secret for the Service Principal.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The Client ID for the Service Principal.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        The Client Secret for the Service Principal.
        """
        return pulumi.get(self, "client_secret")


@pulumi.output_type
class KubernetesClusterWindowsProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adminUsername":
            suggest = "admin_username"
        elif key == "adminPassword":
            suggest = "admin_password"

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

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

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

    def __init__(__self__, *,
                 admin_username: str,
                 admin_password: Optional[str] = None,
                 license: Optional[str] = None):
        """
        :param str admin_username: The Admin Username for Windows VMs.
        :param str admin_password: The Admin Password for Windows VMs. Length must be between 14 and 123 characters.
        :param str license: Specifies the type of on-premise license which should be used for Node Pool Windows Virtual Machine. At this time the only possible value is `Windows_Server`.
        """
        pulumi.set(__self__, "admin_username", admin_username)
        if admin_password is not None:
            pulumi.set(__self__, "admin_password", admin_password)
        if license is not None:
            pulumi.set(__self__, "license", license)

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> str:
        """
        The Admin Username for Windows VMs.
        """
        return pulumi.get(self, "admin_username")

    @property
    @pulumi.getter(name="adminPassword")
    def admin_password(self) -> Optional[str]:
        """
        The Admin Password for Windows VMs. Length must be between 14 and 123 characters.
        """
        return pulumi.get(self, "admin_password")

    @property
    @pulumi.getter
    def license(self) -> Optional[str]:
        """
        Specifies the type of on-premise license which should be used for Node Pool Windows Virtual Machine. At this time the only possible value is `Windows_Server`.
        """
        return pulumi.get(self, "license")


@pulumi.output_type
class RegistryEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityClientId":
            suggest = "identity_client_id"
        elif key == "keyVaultKeyId":
            suggest = "key_vault_key_id"

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

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

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

    def __init__(__self__, *,
                 identity_client_id: str,
                 key_vault_key_id: str,
                 enabled: Optional[bool] = None):
        """
        :param str identity_client_id: The client ID of the managed identity associated with the encryption key.
        :param str key_vault_key_id: The ID of the Key Vault Key.
        :param bool enabled: Boolean value that indicates whether encryption is enabled.
        """
        pulumi.set(__self__, "identity_client_id", identity_client_id)
        pulumi.set(__self__, "key_vault_key_id", key_vault_key_id)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="identityClientId")
    def identity_client_id(self) -> str:
        """
        The client ID of the managed identity associated with the encryption key.
        """
        return pulumi.get(self, "identity_client_id")

    @property
    @pulumi.getter(name="keyVaultKeyId")
    def key_vault_key_id(self) -> str:
        """
        The ID of the Key Vault Key.
        """
        return pulumi.get(self, "key_vault_key_id")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Boolean value that indicates whether encryption is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class RegistryGeoreplication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "regionalEndpointEnabled":
            suggest = "regional_endpoint_enabled"
        elif key == "zoneRedundancyEnabled":
            suggest = "zone_redundancy_enabled"

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

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

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

    def __init__(__self__, *,
                 location: str,
                 regional_endpoint_enabled: Optional[bool] = None,
                 tags: Optional[Mapping[str, str]] = None,
                 zone_redundancy_enabled: Optional[bool] = None):
        """
        :param str location: A location where the container registry should be geo-replicated.
        :param bool regional_endpoint_enabled: Whether regional endpoint is enabled for this Container Registry? Defaults to `false`.
        :param Mapping[str, str] tags: A mapping of tags to assign to this replication location.
        :param bool zone_redundancy_enabled: Whether zone redundancy is enabled for this replication location? Defaults to `false`.
        """
        pulumi.set(__self__, "location", location)
        if regional_endpoint_enabled is not None:
            pulumi.set(__self__, "regional_endpoint_enabled", regional_endpoint_enabled)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if zone_redundancy_enabled is not None:
            pulumi.set(__self__, "zone_redundancy_enabled", zone_redundancy_enabled)

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        A location where the container registry should be geo-replicated.
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="regionalEndpointEnabled")
    def regional_endpoint_enabled(self) -> Optional[bool]:
        """
        Whether regional endpoint is enabled for this Container Registry? Defaults to `false`.
        """
        return pulumi.get(self, "regional_endpoint_enabled")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, str]]:
        """
        A mapping of tags to assign to this replication location.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="zoneRedundancyEnabled")
    def zone_redundancy_enabled(self) -> Optional[bool]:
        """
        Whether zone redundancy is enabled for this replication location? Defaults to `false`.
        """
        return pulumi.get(self, "zone_redundancy_enabled")


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

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

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

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

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: The type of Managed Identity which should be assigned to the Container Registry. Possible values are `SystemAssigned`, `UserAssigned` and `SystemAssigned, UserAssigned`.
        :param Sequence[str] identity_ids: A list of User Managed Identity ID's which should be assigned to the Container Registry.
        :param str principal_id: The Principal ID for the Service Principal associated with the Managed Service Identity of this Container Registry.
        :param str tenant_id: The Tenant ID for the Service Principal associated with the Managed Service Identity of this Container Registry.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of Managed Identity which should be assigned to the Container Registry. Possible values are `SystemAssigned`, `UserAssigned` and `SystemAssigned, UserAssigned`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        A list of User Managed Identity ID's which should be assigned to the Container Registry.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[str]:
        """
        The Principal ID for the Service Principal associated with the Managed Service Identity of this Container Registry.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        The Tenant ID for the Service Principal associated with the Managed Service Identity of this Container Registry.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class RegistryNetworkRuleSet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultAction":
            suggest = "default_action"
        elif key == "ipRules":
            suggest = "ip_rules"
        elif key == "virtualNetworks":
            suggest = "virtual_networks"

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

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

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

    def __init__(__self__, *,
                 default_action: Optional[str] = None,
                 ip_rules: Optional[Sequence['outputs.RegistryNetworkRuleSetIpRule']] = None,
                 virtual_networks: Optional[Sequence['outputs.RegistryNetworkRuleSetVirtualNetwork']] = None):
        """
        :param str default_action: The behaviour for requests matching no rules. Either `Allow` or `Deny`. Defaults to `Allow`
        :param Sequence['RegistryNetworkRuleSetIpRuleArgs'] ip_rules: One or more `ip_rule` blocks as defined below.
        :param Sequence['RegistryNetworkRuleSetVirtualNetworkArgs'] virtual_networks: One or more `virtual_network` blocks as defined below.
        """
        if default_action is not None:
            pulumi.set(__self__, "default_action", default_action)
        if ip_rules is not None:
            pulumi.set(__self__, "ip_rules", ip_rules)
        if virtual_networks is not None:
            pulumi.set(__self__, "virtual_networks", virtual_networks)

    @property
    @pulumi.getter(name="defaultAction")
    def default_action(self) -> Optional[str]:
        """
        The behaviour for requests matching no rules. Either `Allow` or `Deny`. Defaults to `Allow`
        """
        return pulumi.get(self, "default_action")

    @property
    @pulumi.getter(name="ipRules")
    def ip_rules(self) -> Optional[Sequence['outputs.RegistryNetworkRuleSetIpRule']]:
        """
        One or more `ip_rule` blocks as defined below.
        """
        return pulumi.get(self, "ip_rules")

    @property
    @pulumi.getter(name="virtualNetworks")
    def virtual_networks(self) -> Optional[Sequence['outputs.RegistryNetworkRuleSetVirtualNetwork']]:
        """
        One or more `virtual_network` blocks as defined below.
        """
        return pulumi.get(self, "virtual_networks")


@pulumi.output_type
class RegistryNetworkRuleSetIpRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipRange":
            suggest = "ip_range"

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

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

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

    def __init__(__self__, *,
                 action: str,
                 ip_range: str):
        """
        :param str action: The behaviour for requests matching this rule. At this time the only supported value is `Allow`
        :param str ip_range: The CIDR block from which requests will match the rule.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "ip_range", ip_range)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        The behaviour for requests matching this rule. At this time the only supported value is `Allow`
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter(name="ipRange")
    def ip_range(self) -> str:
        """
        The CIDR block from which requests will match the rule.
        """
        return pulumi.get(self, "ip_range")


@pulumi.output_type
class RegistryNetworkRuleSetVirtualNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"

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

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

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

    def __init__(__self__, *,
                 action: str,
                 subnet_id: str):
        """
        :param str action: The behaviour for requests matching this rule. At this time the only supported value is `Allow`
        :param str subnet_id: The subnet id from which requests will match the rule.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        The behaviour for requests matching this rule. At this time the only supported value is `Allow`
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The subnet id from which requests will match the rule.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class RegistryRetentionPolicy(dict):
    def __init__(__self__, *,
                 days: Optional[int] = None,
                 enabled: Optional[bool] = None):
        """
        :param int days: The number of days to retain an untagged manifest after which it gets purged. Default is `7`.
        :param bool enabled: Boolean value that indicates whether the policy is enabled.
        """
        if days is not None:
            pulumi.set(__self__, "days", days)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        The number of days to retain an untagged manifest after which it gets purged. Default is `7`.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Boolean value that indicates whether the policy is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class RegistryTaskAgentSetting(dict):
    def __init__(__self__, *,
                 cpu: int):
        """
        :param int cpu: The number of cores required for the Container Registry Task.
        """
        pulumi.set(__self__, "cpu", cpu)

    @property
    @pulumi.getter
    def cpu(self) -> int:
        """
        The number of cores required for the Container Registry Task.
        """
        return pulumi.get(self, "cpu")


@pulumi.output_type
class RegistryTaskBaseImageTrigger(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "updateTriggerEndpoint":
            suggest = "update_trigger_endpoint"
        elif key == "updateTriggerPayloadType":
            suggest = "update_trigger_payload_type"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 type: str,
                 enabled: Optional[bool] = None,
                 update_trigger_endpoint: Optional[str] = None,
                 update_trigger_payload_type: Optional[str] = None):
        """
        :param str name: The name which should be used for this trigger.
        :param str type: The type of the trigger. Possible values are `All` and `Runtime`.
        :param bool enabled: Should the trigger be enabled? Defaults to `true`.
        :param str update_trigger_endpoint: The endpoint URL for receiving the trigger.
        :param str update_trigger_payload_type: Type of payload body for the trigger. Possible values are `Default` and `Token`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if update_trigger_endpoint is not None:
            pulumi.set(__self__, "update_trigger_endpoint", update_trigger_endpoint)
        if update_trigger_payload_type is not None:
            pulumi.set(__self__, "update_trigger_payload_type", update_trigger_payload_type)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for this trigger.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the trigger. Possible values are `All` and `Runtime`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Should the trigger be enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="updateTriggerEndpoint")
    def update_trigger_endpoint(self) -> Optional[str]:
        """
        The endpoint URL for receiving the trigger.
        """
        return pulumi.get(self, "update_trigger_endpoint")

    @property
    @pulumi.getter(name="updateTriggerPayloadType")
    def update_trigger_payload_type(self) -> Optional[str]:
        """
        Type of payload body for the trigger. Possible values are `Default` and `Token`.
        """
        return pulumi.get(self, "update_trigger_payload_type")


@pulumi.output_type
class RegistryTaskDockerStep(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contextAccessToken":
            suggest = "context_access_token"
        elif key == "contextPath":
            suggest = "context_path"
        elif key == "dockerfilePath":
            suggest = "dockerfile_path"
        elif key == "cacheEnabled":
            suggest = "cache_enabled"
        elif key == "imageNames":
            suggest = "image_names"
        elif key == "pushEnabled":
            suggest = "push_enabled"
        elif key == "secretArguments":
            suggest = "secret_arguments"

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

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

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

    def __init__(__self__, *,
                 context_access_token: str,
                 context_path: str,
                 dockerfile_path: str,
                 arguments: Optional[Mapping[str, str]] = None,
                 cache_enabled: Optional[bool] = None,
                 image_names: Optional[Sequence[str]] = None,
                 push_enabled: Optional[bool] = None,
                 secret_arguments: Optional[Mapping[str, str]] = None,
                 target: Optional[str] = None):
        """
        :param str context_access_token: The token (Git PAT or SAS token of storage account blob) associated with the context for this step.
        :param str context_path: The URL (absolute or relative) of the source context for this step.
        :param str dockerfile_path: The  Dockerfile path relative to the source context.
        :param Mapping[str, str] arguments: Specifies a map of arguments to be used when executing this step.
        :param bool cache_enabled: Should the image cache be enabled? Defaults to `true`.
        :param Sequence[str] image_names: Specifies a list of fully qualified image names including the repository and tag.
        :param bool push_enabled: Should the image built be pushed to the registry or not? Defaults to `true`.
        :param Mapping[str, str] secret_arguments: Specifies a map of *secret* arguments to be used when executing this step.
        :param str target: The name of the target build stage for the docker build.
        """
        pulumi.set(__self__, "context_access_token", context_access_token)
        pulumi.set(__self__, "context_path", context_path)
        pulumi.set(__self__, "dockerfile_path", dockerfile_path)
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)
        if cache_enabled is not None:
            pulumi.set(__self__, "cache_enabled", cache_enabled)
        if image_names is not None:
            pulumi.set(__self__, "image_names", image_names)
        if push_enabled is not None:
            pulumi.set(__self__, "push_enabled", push_enabled)
        if secret_arguments is not None:
            pulumi.set(__self__, "secret_arguments", secret_arguments)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter(name="contextAccessToken")
    def context_access_token(self) -> str:
        """
        The token (Git PAT or SAS token of storage account blob) associated with the context for this step.
        """
        return pulumi.get(self, "context_access_token")

    @property
    @pulumi.getter(name="contextPath")
    def context_path(self) -> str:
        """
        The URL (absolute or relative) of the source context for this step.
        """
        return pulumi.get(self, "context_path")

    @property
    @pulumi.getter(name="dockerfilePath")
    def dockerfile_path(self) -> str:
        """
        The  Dockerfile path relative to the source context.
        """
        return pulumi.get(self, "dockerfile_path")

    @property
    @pulumi.getter
    def arguments(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of arguments to be used when executing this step.
        """
        return pulumi.get(self, "arguments")

    @property
    @pulumi.getter(name="cacheEnabled")
    def cache_enabled(self) -> Optional[bool]:
        """
        Should the image cache be enabled? Defaults to `true`.
        """
        return pulumi.get(self, "cache_enabled")

    @property
    @pulumi.getter(name="imageNames")
    def image_names(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of fully qualified image names including the repository and tag.
        """
        return pulumi.get(self, "image_names")

    @property
    @pulumi.getter(name="pushEnabled")
    def push_enabled(self) -> Optional[bool]:
        """
        Should the image built be pushed to the registry or not? Defaults to `true`.
        """
        return pulumi.get(self, "push_enabled")

    @property
    @pulumi.getter(name="secretArguments")
    def secret_arguments(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of *secret* arguments to be used when executing this step.
        """
        return pulumi.get(self, "secret_arguments")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        The name of the target build stage for the docker build.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class RegistryTaskEncodedStep(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "taskContent":
            suggest = "task_content"
        elif key == "contextAccessToken":
            suggest = "context_access_token"
        elif key == "contextPath":
            suggest = "context_path"
        elif key == "secretValues":
            suggest = "secret_values"
        elif key == "valueContent":
            suggest = "value_content"

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

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

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

    def __init__(__self__, *,
                 task_content: str,
                 context_access_token: Optional[str] = None,
                 context_path: Optional[str] = None,
                 secret_values: Optional[Mapping[str, str]] = None,
                 value_content: Optional[str] = None,
                 values: Optional[Mapping[str, str]] = None):
        """
        :param str task_content: The (optionally base64 encoded) content of the build template.
        :param str context_access_token: The token (Git PAT or SAS token of storage account blob) associated with the context for this step.
        :param str context_path: The URL (absolute or relative) of the source context for this step.
        :param Mapping[str, str] secret_values: Specifies a map of secret values that can be passed when running a task.
        :param str value_content: The (optionally base64 encoded) content of the build parameters.
        :param Mapping[str, str] values: Specifies a map of values that can be passed when running a task.
        """
        pulumi.set(__self__, "task_content", task_content)
        if context_access_token is not None:
            pulumi.set(__self__, "context_access_token", context_access_token)
        if context_path is not None:
            pulumi.set(__self__, "context_path", context_path)
        if secret_values is not None:
            pulumi.set(__self__, "secret_values", secret_values)
        if value_content is not None:
            pulumi.set(__self__, "value_content", value_content)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="taskContent")
    def task_content(self) -> str:
        """
        The (optionally base64 encoded) content of the build template.
        """
        return pulumi.get(self, "task_content")

    @property
    @pulumi.getter(name="contextAccessToken")
    def context_access_token(self) -> Optional[str]:
        """
        The token (Git PAT or SAS token of storage account blob) associated with the context for this step.
        """
        return pulumi.get(self, "context_access_token")

    @property
    @pulumi.getter(name="contextPath")
    def context_path(self) -> Optional[str]:
        """
        The URL (absolute or relative) of the source context for this step.
        """
        return pulumi.get(self, "context_path")

    @property
    @pulumi.getter(name="secretValues")
    def secret_values(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of secret values that can be passed when running a task.
        """
        return pulumi.get(self, "secret_values")

    @property
    @pulumi.getter(name="valueContent")
    def value_content(self) -> Optional[str]:
        """
        The (optionally base64 encoded) content of the build parameters.
        """
        return pulumi.get(self, "value_content")

    @property
    @pulumi.getter
    def values(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of values that can be passed when running a task.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class RegistryTaskFileStep(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "taskFilePath":
            suggest = "task_file_path"
        elif key == "contextAccessToken":
            suggest = "context_access_token"
        elif key == "contextPath":
            suggest = "context_path"
        elif key == "secretValues":
            suggest = "secret_values"
        elif key == "valueFilePath":
            suggest = "value_file_path"

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

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

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

    def __init__(__self__, *,
                 task_file_path: str,
                 context_access_token: Optional[str] = None,
                 context_path: Optional[str] = None,
                 secret_values: Optional[Mapping[str, str]] = None,
                 value_file_path: Optional[str] = None,
                 values: Optional[Mapping[str, str]] = None):
        """
        :param str task_file_path: The task template file path relative to the source context.
        :param str context_access_token: The token (Git PAT or SAS token of storage account blob) associated with the context for this step.
        :param str context_path: The URL (absolute or relative) of the source context for this step.
        :param Mapping[str, str] secret_values: Specifies a map of secret values that can be passed when running a task.
        :param str value_file_path: The parameters file path relative to the source context.
        :param Mapping[str, str] values: Specifies a map of values that can be passed when running a task.
        """
        pulumi.set(__self__, "task_file_path", task_file_path)
        if context_access_token is not None:
            pulumi.set(__self__, "context_access_token", context_access_token)
        if context_path is not None:
            pulumi.set(__self__, "context_path", context_path)
        if secret_values is not None:
            pulumi.set(__self__, "secret_values", secret_values)
        if value_file_path is not None:
            pulumi.set(__self__, "value_file_path", value_file_path)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="taskFilePath")
    def task_file_path(self) -> str:
        """
        The task template file path relative to the source context.
        """
        return pulumi.get(self, "task_file_path")

    @property
    @pulumi.getter(name="contextAccessToken")
    def context_access_token(self) -> Optional[str]:
        """
        The token (Git PAT or SAS token of storage account blob) associated with the context for this step.
        """
        return pulumi.get(self, "context_access_token")

    @property
    @pulumi.getter(name="contextPath")
    def context_path(self) -> Optional[str]:
        """
        The URL (absolute or relative) of the source context for this step.
        """
        return pulumi.get(self, "context_path")

    @property
    @pulumi.getter(name="secretValues")
    def secret_values(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of secret values that can be passed when running a task.
        """
        return pulumi.get(self, "secret_values")

    @property
    @pulumi.getter(name="valueFilePath")
    def value_file_path(self) -> Optional[str]:
        """
        The parameters file path relative to the source context.
        """
        return pulumi.get(self, "value_file_path")

    @property
    @pulumi.getter
    def values(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of values that can be passed when running a task.
        """
        return pulumi.get(self, "values")


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

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

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

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

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: The type of the identity. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned`.
        :param Sequence[str] identity_ids: Specifies a list of user assigned identity IDs.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

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

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of user assigned identity IDs.
        """
        return pulumi.get(self, "identity_ids")

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

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


@pulumi.output_type
class RegistryTaskPlatform(dict):
    def __init__(__self__, *,
                 os: str,
                 architecture: Optional[str] = None,
                 variant: Optional[str] = None):
        """
        :param str os: The operating system type required for the task. Possible values are `Windows` and `Linux`.
        :param str architecture: The OS architecture. Possible values are `amd64`, `x86`, `386`, `arm` and `arm64`.
        :param str variant: The variant of the CPU. Possible values are `v6`, `v7`, `v8`.
        """
        pulumi.set(__self__, "os", os)
        if architecture is not None:
            pulumi.set(__self__, "architecture", architecture)
        if variant is not None:
            pulumi.set(__self__, "variant", variant)

    @property
    @pulumi.getter
    def os(self) -> str:
        """
        The operating system type required for the task. Possible values are `Windows` and `Linux`.
        """
        return pulumi.get(self, "os")

    @property
    @pulumi.getter
    def architecture(self) -> Optional[str]:
        """
        The OS architecture. Possible values are `amd64`, `x86`, `386`, `arm` and `arm64`.
        """
        return pulumi.get(self, "architecture")

    @property
    @pulumi.getter
    def variant(self) -> Optional[str]:
        """
        The variant of the CPU. Possible values are `v6`, `v7`, `v8`.
        """
        return pulumi.get(self, "variant")


@pulumi.output_type
class RegistryTaskRegistryCredential(dict):
    def __init__(__self__, *,
                 customs: Optional[Sequence['outputs.RegistryTaskRegistryCredentialCustom']] = None,
                 source: Optional['outputs.RegistryTaskRegistryCredentialSource'] = None):
        """
        :param Sequence['RegistryTaskRegistryCredentialCustomArgs'] customs: One or more `custom` blocks as defined above.
        :param 'RegistryTaskRegistryCredentialSourceArgs' source: One `source` block as defined below.
        """
        if customs is not None:
            pulumi.set(__self__, "customs", customs)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter
    def customs(self) -> Optional[Sequence['outputs.RegistryTaskRegistryCredentialCustom']]:
        """
        One or more `custom` blocks as defined above.
        """
        return pulumi.get(self, "customs")

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


@pulumi.output_type
class RegistryTaskRegistryCredentialCustom(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loginServer":
            suggest = "login_server"

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

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

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

    def __init__(__self__, *,
                 login_server: str,
                 identity: Optional[str] = None,
                 password: Optional[str] = None,
                 username: Optional[str] = None):
        """
        :param str login_server: The login server of the custom Container Registry.
        :param str identity: The managed identity assigned to this custom credential. For user assigned identity, the value is the client ID of the identity. For system assigned identity, the value is `system`.
        :param str password: The password for logging into the custom Container Registry. It can be either a plain text of password, or a Keyvault Secret ID.
        :param str username: The username for logging into the custom Container Registry. It can be either a plain text of username, or a Keyvault Secret ID.
        """
        pulumi.set(__self__, "login_server", login_server)
        if identity is not None:
            pulumi.set(__self__, "identity", identity)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="loginServer")
    def login_server(self) -> str:
        """
        The login server of the custom Container Registry.
        """
        return pulumi.get(self, "login_server")

    @property
    @pulumi.getter
    def identity(self) -> Optional[str]:
        """
        The managed identity assigned to this custom credential. For user assigned identity, the value is the client ID of the identity. For system assigned identity, the value is `system`.
        """
        return pulumi.get(self, "identity")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        The password for logging into the custom Container Registry. It can be either a plain text of password, or a Keyvault Secret ID.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        The username for logging into the custom Container Registry. It can be either a plain text of username, or a Keyvault Secret ID.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class RegistryTaskRegistryCredentialSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loginMode":
            suggest = "login_mode"

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

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

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

    def __init__(__self__, *,
                 login_mode: str):
        """
        :param str login_mode: The login mode for the source registry. Possible values are `None` and `Default`.
        """
        pulumi.set(__self__, "login_mode", login_mode)

    @property
    @pulumi.getter(name="loginMode")
    def login_mode(self) -> str:
        """
        The login mode for the source registry. Possible values are `None` and `Default`.
        """
        return pulumi.get(self, "login_mode")


@pulumi.output_type
class RegistryTaskSourceTrigger(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repositoryUrl":
            suggest = "repository_url"
        elif key == "sourceType":
            suggest = "source_type"

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

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

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

    def __init__(__self__, *,
                 events: Sequence[str],
                 name: str,
                 repository_url: str,
                 source_type: str,
                 authentication: Optional['outputs.RegistryTaskSourceTriggerAuthentication'] = None,
                 branch: Optional[str] = None,
                 enabled: Optional[bool] = None):
        """
        :param Sequence[str] events: Specifies a list of source events corresponding to the trigger. Possible values are `commit` and `pullrequest`.
        :param str name: The name which should be used for this trigger.
        :param str repository_url: The full URL to the source code repository.
        :param str source_type: The type of the source control service. Possible values are `Github` and `VisualStudioTeamService`.
        :param 'RegistryTaskSourceTriggerAuthenticationArgs' authentication: A `authentication` block as defined above.
        :param str branch: The branch name of the source code.
        :param bool enabled: Should the trigger be enabled? Defaults to `true`.
        """
        pulumi.set(__self__, "events", events)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "repository_url", repository_url)
        pulumi.set(__self__, "source_type", source_type)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def events(self) -> Sequence[str]:
        """
        Specifies a list of source events corresponding to the trigger. Possible values are `commit` and `pullrequest`.
        """
        return pulumi.get(self, "events")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for this trigger.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="repositoryUrl")
    def repository_url(self) -> str:
        """
        The full URL to the source code repository.
        """
        return pulumi.get(self, "repository_url")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> str:
        """
        The type of the source control service. Possible values are `Github` and `VisualStudioTeamService`.
        """
        return pulumi.get(self, "source_type")

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

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        The branch name of the source code.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Should the trigger be enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class RegistryTaskSourceTriggerAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tokenType":
            suggest = "token_type"
        elif key == "expireInSeconds":
            suggest = "expire_in_seconds"
        elif key == "refreshToken":
            suggest = "refresh_token"

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

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

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

    def __init__(__self__, *,
                 token: str,
                 token_type: str,
                 expire_in_seconds: Optional[int] = None,
                 refresh_token: Optional[str] = None,
                 scope: Optional[str] = None):
        """
        :param str token: The access token used to access the source control provider.
        :param str token_type: The type of the token. Possible values are `PAT` (personal access token) and `OAuth`.
        :param int expire_in_seconds: Time in seconds that the token remains valid.
        :param str refresh_token: The refresh token used to refresh the access token.
        :param str scope: The scope of the access token.
        """
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "token_type", token_type)
        if expire_in_seconds is not None:
            pulumi.set(__self__, "expire_in_seconds", expire_in_seconds)
        if refresh_token is not None:
            pulumi.set(__self__, "refresh_token", refresh_token)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter
    def token(self) -> str:
        """
        The access token used to access the source control provider.
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="tokenType")
    def token_type(self) -> str:
        """
        The type of the token. Possible values are `PAT` (personal access token) and `OAuth`.
        """
        return pulumi.get(self, "token_type")

    @property
    @pulumi.getter(name="expireInSeconds")
    def expire_in_seconds(self) -> Optional[int]:
        """
        Time in seconds that the token remains valid.
        """
        return pulumi.get(self, "expire_in_seconds")

    @property
    @pulumi.getter(name="refreshToken")
    def refresh_token(self) -> Optional[str]:
        """
        The refresh token used to refresh the access token.
        """
        return pulumi.get(self, "refresh_token")

    @property
    @pulumi.getter
    def scope(self) -> Optional[str]:
        """
        The scope of the access token.
        """
        return pulumi.get(self, "scope")


@pulumi.output_type
class RegistryTaskTimerTrigger(dict):
    def __init__(__self__, *,
                 name: str,
                 schedule: str,
                 enabled: Optional[bool] = None):
        """
        :param str name: The name which should be used for this trigger.
        :param str schedule: The CRON expression for the task schedule.
        :param bool enabled: Should the trigger be enabled? Defaults to `true`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schedule", schedule)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for this trigger.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def schedule(self) -> str:
        """
        The CRON expression for the task schedule.
        """
        return pulumi.get(self, "schedule")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Should the trigger be enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class RegistryTrustPolicy(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Boolean value that indicates whether the policy is enabled.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Boolean value that indicates whether the policy is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterNodePoolUpgradeSettingResult(dict):
    def __init__(__self__, *,
                 max_surge: str):
        """
        :param str max_surge: The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        pulumi.set(__self__, "max_surge", max_surge)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> str:
        """
        The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        return pulumi.get(self, "max_surge")


@pulumi.output_type
class GetKubernetesClusterAddonProfileResult(dict):
    def __init__(__self__, *,
                 azure_keyvault_secrets_providers: Sequence['outputs.GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderResult'],
                 azure_policies: Sequence['outputs.GetKubernetesClusterAddonProfileAzurePolicyResult'],
                 http_application_routings: Sequence['outputs.GetKubernetesClusterAddonProfileHttpApplicationRoutingResult'],
                 ingress_application_gateways: Sequence['outputs.GetKubernetesClusterAddonProfileIngressApplicationGatewayResult'],
                 kube_dashboards: Sequence['outputs.GetKubernetesClusterAddonProfileKubeDashboardResult'],
                 oms_agents: Sequence['outputs.GetKubernetesClusterAddonProfileOmsAgentResult'],
                 open_service_meshes: Sequence['outputs.GetKubernetesClusterAddonProfileOpenServiceMeshResult']):
        """
        :param Sequence['GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderArgs'] azure_keyvault_secrets_providers: An `azure_keyvault_secrets_provider` block.
        :param Sequence['GetKubernetesClusterAddonProfileAzurePolicyArgs'] azure_policies: A `azure_policy` block.
        :param Sequence['GetKubernetesClusterAddonProfileHttpApplicationRoutingArgs'] http_application_routings: A `http_application_routing` block.
        :param Sequence['GetKubernetesClusterAddonProfileIngressApplicationGatewayArgs'] ingress_application_gateways: An `ingress_application_gateway` block.
        :param Sequence['GetKubernetesClusterAddonProfileKubeDashboardArgs'] kube_dashboards: A `kube_dashboard` block.
        :param Sequence['GetKubernetesClusterAddonProfileOmsAgentArgs'] oms_agents: A `oms_agent` block.
        :param Sequence['GetKubernetesClusterAddonProfileOpenServiceMeshArgs'] open_service_meshes: An `open_service_mesh` block.
        """
        pulumi.set(__self__, "azure_keyvault_secrets_providers", azure_keyvault_secrets_providers)
        pulumi.set(__self__, "azure_policies", azure_policies)
        pulumi.set(__self__, "http_application_routings", http_application_routings)
        pulumi.set(__self__, "ingress_application_gateways", ingress_application_gateways)
        pulumi.set(__self__, "kube_dashboards", kube_dashboards)
        pulumi.set(__self__, "oms_agents", oms_agents)
        pulumi.set(__self__, "open_service_meshes", open_service_meshes)

    @property
    @pulumi.getter(name="azureKeyvaultSecretsProviders")
    def azure_keyvault_secrets_providers(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderResult']:
        """
        An `azure_keyvault_secrets_provider` block.
        """
        return pulumi.get(self, "azure_keyvault_secrets_providers")

    @property
    @pulumi.getter(name="azurePolicies")
    def azure_policies(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileAzurePolicyResult']:
        """
        A `azure_policy` block.
        """
        return pulumi.get(self, "azure_policies")

    @property
    @pulumi.getter(name="httpApplicationRoutings")
    def http_application_routings(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileHttpApplicationRoutingResult']:
        """
        A `http_application_routing` block.
        """
        return pulumi.get(self, "http_application_routings")

    @property
    @pulumi.getter(name="ingressApplicationGateways")
    def ingress_application_gateways(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileIngressApplicationGatewayResult']:
        """
        An `ingress_application_gateway` block.
        """
        return pulumi.get(self, "ingress_application_gateways")

    @property
    @pulumi.getter(name="kubeDashboards")
    def kube_dashboards(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileKubeDashboardResult']:
        """
        A `kube_dashboard` block.
        """
        return pulumi.get(self, "kube_dashboards")

    @property
    @pulumi.getter(name="omsAgents")
    def oms_agents(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileOmsAgentResult']:
        """
        A `oms_agent` block.
        """
        return pulumi.get(self, "oms_agents")

    @property
    @pulumi.getter(name="openServiceMeshes")
    def open_service_meshes(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileOpenServiceMeshResult']:
        """
        An `open_service_mesh` block.
        """
        return pulumi.get(self, "open_service_meshes")


@pulumi.output_type
class GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 secret_identities: Sequence['outputs.GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentityResult'],
                 secret_rotation_enabled: str,
                 secret_rotation_interval: str):
        """
        :param bool enabled: Is Role Based Access Control enabled?
        :param str secret_rotation_enabled: Is secret rotation enabled?
        :param str secret_rotation_interval: The interval to poll for secret rotation.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "secret_identities", secret_identities)
        pulumi.set(__self__, "secret_rotation_enabled", secret_rotation_enabled)
        pulumi.set(__self__, "secret_rotation_interval", secret_rotation_interval)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="secretIdentities")
    def secret_identities(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentityResult']:
        return pulumi.get(self, "secret_identities")

    @property
    @pulumi.getter(name="secretRotationEnabled")
    def secret_rotation_enabled(self) -> str:
        """
        Is secret rotation enabled?
        """
        return pulumi.get(self, "secret_rotation_enabled")

    @property
    @pulumi.getter(name="secretRotationInterval")
    def secret_rotation_interval(self) -> str:
        """
        The interval to poll for secret rotation.
        """
        return pulumi.get(self, "secret_rotation_interval")


@pulumi.output_type
class GetKubernetesClusterAddonProfileAzureKeyvaultSecretsProviderSecretIdentityResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 object_id: str,
                 user_assigned_identity_id: str):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str user_assigned_identity_id: The ID of the User Assigned Identity assigned to the Kubelets.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "object_id", object_id)
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> str:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> str:
        """
        The ID of the User Assigned Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class GetKubernetesClusterAddonProfileAzurePolicyResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Is Role Based Access Control enabled?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetKubernetesClusterAddonProfileHttpApplicationRoutingResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 http_application_routing_zone_name: str):
        """
        :param bool enabled: Is Role Based Access Control enabled?
        :param str http_application_routing_zone_name: The Zone Name of the HTTP Application Routing.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "http_application_routing_zone_name", http_application_routing_zone_name)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="httpApplicationRoutingZoneName")
    def http_application_routing_zone_name(self) -> str:
        """
        The Zone Name of the HTTP Application Routing.
        """
        return pulumi.get(self, "http_application_routing_zone_name")


@pulumi.output_type
class GetKubernetesClusterAddonProfileIngressApplicationGatewayResult(dict):
    def __init__(__self__, *,
                 effective_gateway_id: str,
                 enabled: bool,
                 gateway_id: str,
                 ingress_application_gateway_identities: Sequence['outputs.GetKubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentityResult'],
                 subnet_cidr: str,
                 subnet_id: str):
        """
        :param str effective_gateway_id: The ID of the Application Gateway associated with the ingress controller deployed to this Kubernetes Cluster.
        :param bool enabled: Is Role Based Access Control enabled?
        :param str gateway_id: The ID of the Application Gateway integrated with the ingress controller of this Kubernetes Cluster. This attribute is only set when gateway_id is specified when configuring the `ingress_application_gateway` addon.
        :param Sequence['GetKubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentityArgs'] ingress_application_gateway_identities: An `ingress_application_gateway_identity` block as defined below.
        :param str subnet_cidr: The subnet CIDR used to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. This attribute is only set when `subnet_cidr` is specified when configuring the `ingress_application_gateway` addon.
        :param str subnet_id: The ID of the subnet on which to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. This attribute is only set when `subnet_id` is specified when configuring the `ingress_application_gateway` addon.
        """
        pulumi.set(__self__, "effective_gateway_id", effective_gateway_id)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "gateway_id", gateway_id)
        pulumi.set(__self__, "ingress_application_gateway_identities", ingress_application_gateway_identities)
        pulumi.set(__self__, "subnet_cidr", subnet_cidr)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="effectiveGatewayId")
    def effective_gateway_id(self) -> str:
        """
        The ID of the Application Gateway associated with the ingress controller deployed to this Kubernetes Cluster.
        """
        return pulumi.get(self, "effective_gateway_id")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="gatewayId")
    def gateway_id(self) -> str:
        """
        The ID of the Application Gateway integrated with the ingress controller of this Kubernetes Cluster. This attribute is only set when gateway_id is specified when configuring the `ingress_application_gateway` addon.
        """
        return pulumi.get(self, "gateway_id")

    @property
    @pulumi.getter(name="ingressApplicationGatewayIdentities")
    def ingress_application_gateway_identities(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentityResult']:
        """
        An `ingress_application_gateway_identity` block as defined below.
        """
        return pulumi.get(self, "ingress_application_gateway_identities")

    @property
    @pulumi.getter(name="subnetCidr")
    def subnet_cidr(self) -> str:
        """
        The subnet CIDR used to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. This attribute is only set when `subnet_cidr` is specified when configuring the `ingress_application_gateway` addon.
        """
        return pulumi.get(self, "subnet_cidr")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ID of the subnet on which to create an Application Gateway, which in turn will be integrated with the ingress controller of this Kubernetes Cluster. This attribute is only set when `subnet_id` is specified when configuring the `ingress_application_gateway` addon.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetKubernetesClusterAddonProfileIngressApplicationGatewayIngressApplicationGatewayIdentityResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 object_id: str,
                 user_assigned_identity_id: str):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str user_assigned_identity_id: The ID of the User Assigned Identity assigned to the Kubelets.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "object_id", object_id)
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> str:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> str:
        """
        The ID of the User Assigned Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class GetKubernetesClusterAddonProfileKubeDashboardResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Is Role Based Access Control enabled?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetKubernetesClusterAddonProfileOmsAgentResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 log_analytics_workspace_id: str,
                 oms_agent_identities: Sequence['outputs.GetKubernetesClusterAddonProfileOmsAgentOmsAgentIdentityResult']):
        """
        :param bool enabled: Is Role Based Access Control enabled?
        :param str log_analytics_workspace_id: The ID of the Log Analytics Workspace which the OMS Agent should send data to.
        :param Sequence['GetKubernetesClusterAddonProfileOmsAgentOmsAgentIdentityArgs'] oms_agent_identities: An `oms_agent_identity` block as defined below.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "log_analytics_workspace_id", log_analytics_workspace_id)
        pulumi.set(__self__, "oms_agent_identities", oms_agent_identities)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceId")
    def log_analytics_workspace_id(self) -> str:
        """
        The ID of the Log Analytics Workspace which the OMS Agent should send data to.
        """
        return pulumi.get(self, "log_analytics_workspace_id")

    @property
    @pulumi.getter(name="omsAgentIdentities")
    def oms_agent_identities(self) -> Sequence['outputs.GetKubernetesClusterAddonProfileOmsAgentOmsAgentIdentityResult']:
        """
        An `oms_agent_identity` block as defined below.
        """
        return pulumi.get(self, "oms_agent_identities")


@pulumi.output_type
class GetKubernetesClusterAddonProfileOmsAgentOmsAgentIdentityResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 object_id: str,
                 user_assigned_identity_id: str):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str user_assigned_identity_id: The ID of the User Assigned Identity assigned to the Kubelets.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "object_id", object_id)
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> str:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> str:
        """
        The ID of the User Assigned Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class GetKubernetesClusterAddonProfileOpenServiceMeshResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Is Role Based Access Control enabled?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetKubernetesClusterAgentPoolProfileResult(dict):
    def __init__(__self__, *,
                 availability_zones: Sequence[str],
                 count: int,
                 enable_auto_scaling: bool,
                 enable_node_public_ip: bool,
                 max_count: int,
                 max_pods: int,
                 min_count: int,
                 name: str,
                 node_labels: Mapping[str, str],
                 node_public_ip_prefix_id: str,
                 node_taints: Sequence[str],
                 orchestrator_version: str,
                 os_disk_size_gb: int,
                 os_type: str,
                 tags: Mapping[str, str],
                 type: str,
                 upgrade_settings: Sequence['outputs.GetKubernetesClusterAgentPoolProfileUpgradeSettingResult'],
                 vm_size: str,
                 vnet_subnet_id: str):
        """
        :param Sequence[str] availability_zones: The availability zones used for the nodes.
        :param int count: The number of Agents (VM's) in the Pool.
        :param bool enable_auto_scaling: If the auto-scaler is enabled.
        :param bool enable_node_public_ip: If the Public IPs for the nodes in this Agent Pool are enabled.
        :param int max_count: Maximum number of nodes for auto-scaling
        :param int max_pods: The maximum number of pods that can run on each agent.
        :param int min_count: Minimum number of nodes for auto-scaling
        :param str name: The name of the managed Kubernetes Cluster.
        :param str node_public_ip_prefix_id: Resource ID for the Public IP Addresses Prefix for the nodes in this Agent Pool.
        :param str orchestrator_version: Kubernetes version used for the Agents.
        :param int os_disk_size_gb: The size of the Agent VM's Operating System Disk in GB.
        :param str os_type: The Operating System used for the Agents.
        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
        :param str type: The type of identity used for the managed cluster.
        :param Sequence['GetKubernetesClusterAgentPoolProfileUpgradeSettingArgs'] upgrade_settings: A `upgrade_settings` block as documented below.
        :param str vm_size: The size of each VM in the Agent Pool (e.g. `Standard_F1`).
        :param str vnet_subnet_id: The ID of the Subnet where the Agents in the Pool are provisioned.
        """
        pulumi.set(__self__, "availability_zones", availability_zones)
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
        pulumi.set(__self__, "enable_node_public_ip", enable_node_public_ip)
        pulumi.set(__self__, "max_count", max_count)
        pulumi.set(__self__, "max_pods", max_pods)
        pulumi.set(__self__, "min_count", min_count)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "node_labels", node_labels)
        pulumi.set(__self__, "node_public_ip_prefix_id", node_public_ip_prefix_id)
        pulumi.set(__self__, "node_taints", node_taints)
        pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        pulumi.set(__self__, "os_type", os_type)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "upgrade_settings", upgrade_settings)
        pulumi.set(__self__, "vm_size", vm_size)
        pulumi.set(__self__, "vnet_subnet_id", vnet_subnet_id)

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> Sequence[str]:
        """
        The availability zones used for the nodes.
        """
        return pulumi.get(self, "availability_zones")

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        The number of Agents (VM's) in the Pool.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="enableAutoScaling")
    def enable_auto_scaling(self) -> bool:
        """
        If the auto-scaler is enabled.
        """
        return pulumi.get(self, "enable_auto_scaling")

    @property
    @pulumi.getter(name="enableNodePublicIp")
    def enable_node_public_ip(self) -> bool:
        """
        If the Public IPs for the nodes in this Agent Pool are enabled.
        """
        return pulumi.get(self, "enable_node_public_ip")

    @property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> int:
        """
        Maximum number of nodes for auto-scaling
        """
        return pulumi.get(self, "max_count")

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> int:
        """
        The maximum number of pods that can run on each agent.
        """
        return pulumi.get(self, "max_pods")

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> int:
        """
        Minimum number of nodes for auto-scaling
        """
        return pulumi.get(self, "min_count")

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

    @property
    @pulumi.getter(name="nodeLabels")
    def node_labels(self) -> Mapping[str, str]:
        return pulumi.get(self, "node_labels")

    @property
    @pulumi.getter(name="nodePublicIpPrefixId")
    def node_public_ip_prefix_id(self) -> str:
        """
        Resource ID for the Public IP Addresses Prefix for the nodes in this Agent Pool.
        """
        return pulumi.get(self, "node_public_ip_prefix_id")

    @property
    @pulumi.getter(name="nodeTaints")
    def node_taints(self) -> Sequence[str]:
        return pulumi.get(self, "node_taints")

    @property
    @pulumi.getter(name="orchestratorVersion")
    def orchestrator_version(self) -> str:
        """
        Kubernetes version used for the Agents.
        """
        return pulumi.get(self, "orchestrator_version")

    @property
    @pulumi.getter(name="osDiskSizeGb")
    def os_disk_size_gb(self) -> int:
        """
        The size of the Agent VM's Operating System Disk in GB.
        """
        return pulumi.get(self, "os_disk_size_gb")

    @property
    @pulumi.getter(name="osType")
    def os_type(self) -> str:
        """
        The Operating System used for the Agents.
        """
        return pulumi.get(self, "os_type")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, str]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of identity used for the managed cluster.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="upgradeSettings")
    def upgrade_settings(self) -> Sequence['outputs.GetKubernetesClusterAgentPoolProfileUpgradeSettingResult']:
        """
        A `upgrade_settings` block as documented below.
        """
        return pulumi.get(self, "upgrade_settings")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The size of each VM in the Agent Pool (e.g. `Standard_F1`).
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="vnetSubnetId")
    def vnet_subnet_id(self) -> str:
        """
        The ID of the Subnet where the Agents in the Pool are provisioned.
        """
        return pulumi.get(self, "vnet_subnet_id")


@pulumi.output_type
class GetKubernetesClusterAgentPoolProfileUpgradeSettingResult(dict):
    def __init__(__self__, *,
                 max_surge: str):
        """
        :param str max_surge: The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        pulumi.set(__self__, "max_surge", max_surge)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> str:
        """
        The maximum number or percentage of nodes which will be added to the Node Pool size during an upgrade.
        """
        return pulumi.get(self, "max_surge")


@pulumi.output_type
class GetKubernetesClusterIdentityResult(dict):
    def __init__(__self__, *,
                 principal_id: str,
                 tenant_id: str,
                 type: str,
                 user_assigned_identity_id: str):
        """
        :param str principal_id: The principal id of the system assigned identity which is used by primary components.
        :param str tenant_id: The tenant id of the system assigned identity which is used by primary components.
        :param str type: The type of identity used for the managed cluster.
        :param str user_assigned_identity_id: The ID of the User Assigned Identity assigned to the Kubelets.
        """
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The principal id of the system assigned identity which is used by primary components.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The tenant id of the system assigned identity which is used by primary components.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of identity used for the managed cluster.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> str:
        """
        The ID of the User Assigned Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class GetKubernetesClusterKubeAdminConfigResult(dict):
    def __init__(__self__, *,
                 client_certificate: str,
                 client_key: str,
                 cluster_ca_certificate: str,
                 host: str,
                 password: str,
                 username: str):
        """
        :param str client_certificate: Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        :param str client_key: Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        :param str cluster_ca_certificate: Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        :param str host: The Kubernetes cluster server host.
        :param str password: A password or token used to authenticate to the Kubernetes cluster.
        :param str username: A username used to authenticate to the Kubernetes cluster.
        """
        pulumi.set(__self__, "client_certificate", client_certificate)
        pulumi.set(__self__, "client_key", client_key)
        pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="clientCertificate")
    def client_certificate(self) -> str:
        """
        Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_certificate")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> str:
        """
        Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clusterCaCertificate")
    def cluster_ca_certificate(self) -> str:
        """
        Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        """
        return pulumi.get(self, "cluster_ca_certificate")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        The Kubernetes cluster server host.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        A password or token used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        A username used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetKubernetesClusterKubeConfigResult(dict):
    def __init__(__self__, *,
                 client_certificate: str,
                 client_key: str,
                 cluster_ca_certificate: str,
                 host: str,
                 password: str,
                 username: str):
        """
        :param str client_certificate: Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        :param str client_key: Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        :param str cluster_ca_certificate: Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        :param str host: The Kubernetes cluster server host.
        :param str password: A password or token used to authenticate to the Kubernetes cluster.
        :param str username: A username used to authenticate to the Kubernetes cluster.
        """
        pulumi.set(__self__, "client_certificate", client_certificate)
        pulumi.set(__self__, "client_key", client_key)
        pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="clientCertificate")
    def client_certificate(self) -> str:
        """
        Base64 encoded public certificate used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_certificate")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> str:
        """
        Base64 encoded private key used by clients to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clusterCaCertificate")
    def cluster_ca_certificate(self) -> str:
        """
        Base64 encoded public CA certificate used as the root of trust for the Kubernetes cluster.
        """
        return pulumi.get(self, "cluster_ca_certificate")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        The Kubernetes cluster server host.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        A password or token used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        A username used to authenticate to the Kubernetes cluster.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetKubernetesClusterKubeletIdentityResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 object_id: str,
                 user_assigned_identity_id: str):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str object_id: The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        :param str user_assigned_identity_id: The ID of the User Assigned Identity assigned to the Kubelets.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "object_id", object_id)
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> str:
        """
        The Object ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> str:
        """
        The ID of the User Assigned Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "user_assigned_identity_id")


@pulumi.output_type
class GetKubernetesClusterLinuxProfileResult(dict):
    def __init__(__self__, *,
                 admin_username: str,
                 ssh_keys: Sequence['outputs.GetKubernetesClusterLinuxProfileSshKeyResult']):
        """
        :param str admin_username: The username associated with the administrator account of the Windows VMs.
        :param Sequence['GetKubernetesClusterLinuxProfileSshKeyArgs'] ssh_keys: An `ssh_key` block as defined below.
        """
        pulumi.set(__self__, "admin_username", admin_username)
        pulumi.set(__self__, "ssh_keys", ssh_keys)

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> str:
        """
        The username associated with the administrator account of the Windows VMs.
        """
        return pulumi.get(self, "admin_username")

    @property
    @pulumi.getter(name="sshKeys")
    def ssh_keys(self) -> Sequence['outputs.GetKubernetesClusterLinuxProfileSshKeyResult']:
        """
        An `ssh_key` block as defined below.
        """
        return pulumi.get(self, "ssh_keys")


@pulumi.output_type
class GetKubernetesClusterLinuxProfileSshKeyResult(dict):
    def __init__(__self__, *,
                 key_data: str):
        """
        :param str key_data: The Public SSH Key used to access the cluster.
        """
        pulumi.set(__self__, "key_data", key_data)

    @property
    @pulumi.getter(name="keyData")
    def key_data(self) -> str:
        """
        The Public SSH Key used to access the cluster.
        """
        return pulumi.get(self, "key_data")


@pulumi.output_type
class GetKubernetesClusterNetworkProfileResult(dict):
    def __init__(__self__, *,
                 dns_service_ip: str,
                 docker_bridge_cidr: str,
                 load_balancer_sku: str,
                 network_plugin: str,
                 network_policy: str,
                 pod_cidr: str,
                 service_cidr: str):
        """
        :param str dns_service_ip: IP address within the Kubernetes service address range used by cluster service discovery (kube-dns).
        :param str docker_bridge_cidr: IP address (in CIDR notation) used as the Docker bridge IP address on nodes.
        :param str network_plugin: Network plugin used such as `azure` or `kubenet`.
        :param str network_policy: Network policy to be used with Azure CNI. Eg: `calico` or `azure`
        :param str pod_cidr: The CIDR used for pod IP addresses.
        :param str service_cidr: Network range used by the Kubernetes service.
        """
        pulumi.set(__self__, "dns_service_ip", dns_service_ip)
        pulumi.set(__self__, "docker_bridge_cidr", docker_bridge_cidr)
        pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        pulumi.set(__self__, "network_plugin", network_plugin)
        pulumi.set(__self__, "network_policy", network_policy)
        pulumi.set(__self__, "pod_cidr", pod_cidr)
        pulumi.set(__self__, "service_cidr", service_cidr)

    @property
    @pulumi.getter(name="dnsServiceIp")
    def dns_service_ip(self) -> str:
        """
        IP address within the Kubernetes service address range used by cluster service discovery (kube-dns).
        """
        return pulumi.get(self, "dns_service_ip")

    @property
    @pulumi.getter(name="dockerBridgeCidr")
    def docker_bridge_cidr(self) -> str:
        """
        IP address (in CIDR notation) used as the Docker bridge IP address on nodes.
        """
        return pulumi.get(self, "docker_bridge_cidr")

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

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> str:
        """
        Network plugin used such as `azure` or `kubenet`.
        """
        return pulumi.get(self, "network_plugin")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> str:
        """
        Network policy to be used with Azure CNI. Eg: `calico` or `azure`
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> str:
        """
        The CIDR used for pod IP addresses.
        """
        return pulumi.get(self, "pod_cidr")

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> str:
        """
        Network range used by the Kubernetes service.
        """
        return pulumi.get(self, "service_cidr")


@pulumi.output_type
class GetKubernetesClusterRoleBasedAccessControlResult(dict):
    def __init__(__self__, *,
                 azure_active_directories: Sequence['outputs.GetKubernetesClusterRoleBasedAccessControlAzureActiveDirectoryResult'],
                 enabled: bool):
        """
        :param Sequence['GetKubernetesClusterRoleBasedAccessControlAzureActiveDirectoryArgs'] azure_active_directories: A `azure_active_directory` block as documented above.
        :param bool enabled: Is Role Based Access Control enabled?
        """
        pulumi.set(__self__, "azure_active_directories", azure_active_directories)
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="azureActiveDirectories")
    def azure_active_directories(self) -> Sequence['outputs.GetKubernetesClusterRoleBasedAccessControlAzureActiveDirectoryResult']:
        """
        A `azure_active_directory` block as documented above.
        """
        return pulumi.get(self, "azure_active_directories")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is Role Based Access Control enabled?
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetKubernetesClusterRoleBasedAccessControlAzureActiveDirectoryResult(dict):
    def __init__(__self__, *,
                 admin_group_object_ids: Sequence[str],
                 client_app_id: str,
                 managed: bool,
                 server_app_id: str,
                 tenant_id: str):
        """
        :param Sequence[str] admin_group_object_ids: The list of Object IDs of Azure Active Directory Groups which have Admin Role on the Cluster (when using a Managed integration).
        :param str client_app_id: The Client ID of an Azure Active Directory Application.
        :param bool managed: Is the Azure Active Directory Integration managed (also known as AAD Integration V2)?
        :param str server_app_id: The Server ID of an Azure Active Directory Application.
        :param str tenant_id: The tenant id of the system assigned identity which is used by primary components.
        """
        pulumi.set(__self__, "admin_group_object_ids", admin_group_object_ids)
        pulumi.set(__self__, "client_app_id", client_app_id)
        pulumi.set(__self__, "managed", managed)
        pulumi.set(__self__, "server_app_id", server_app_id)
        pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="adminGroupObjectIds")
    def admin_group_object_ids(self) -> Sequence[str]:
        """
        The list of Object IDs of Azure Active Directory Groups which have Admin Role on the Cluster (when using a Managed integration).
        """
        return pulumi.get(self, "admin_group_object_ids")

    @property
    @pulumi.getter(name="clientAppId")
    def client_app_id(self) -> str:
        """
        The Client ID of an Azure Active Directory Application.
        """
        return pulumi.get(self, "client_app_id")

    @property
    @pulumi.getter
    def managed(self) -> bool:
        """
        Is the Azure Active Directory Integration managed (also known as AAD Integration V2)?
        """
        return pulumi.get(self, "managed")

    @property
    @pulumi.getter(name="serverAppId")
    def server_app_id(self) -> str:
        """
        The Server ID of an Azure Active Directory Application.
        """
        return pulumi.get(self, "server_app_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The tenant id of the system assigned identity which is used by primary components.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class GetKubernetesClusterServicePrincipalResult(dict):
    def __init__(__self__, *,
                 client_id: str):
        """
        :param str client_id: The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        pulumi.set(__self__, "client_id", client_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The Client ID of the user-defined Managed Identity assigned to the Kubelets.
        """
        return pulumi.get(self, "client_id")


@pulumi.output_type
class GetKubernetesClusterWindowsProfileResult(dict):
    def __init__(__self__, *,
                 admin_username: str):
        """
        :param str admin_username: The username associated with the administrator account of the Windows VMs.
        """
        pulumi.set(__self__, "admin_username", admin_username)

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> str:
        """
        The username associated with the administrator account of the Windows VMs.
        """
        return pulumi.get(self, "admin_username")


