# 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__ = [
    'AccountKeyVaultReference',
    'PoolAutoScale',
    'PoolCertificate',
    'PoolContainerConfiguration',
    'PoolContainerConfigurationContainerRegistry',
    'PoolFixedScale',
    'PoolNetworkConfiguration',
    'PoolNetworkConfigurationEndpointConfiguration',
    'PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule',
    'PoolStartTask',
    'PoolStartTaskResourceFile',
    'PoolStartTaskUserIdentity',
    'PoolStartTaskUserIdentityAutoUser',
    'PoolStorageImageReference',
    'GetAccountKeyVaultReferenceResult',
    'GetPoolAutoScaleResult',
    'GetPoolCertificateResult',
    'GetPoolContainerConfigurationResult',
    'GetPoolContainerConfigurationContainerRegistryResult',
    'GetPoolFixedScaleResult',
    'GetPoolNetworkConfigurationResult',
    'GetPoolNetworkConfigurationEndpointConfigurationResult',
    'GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleResult',
    'GetPoolStartTaskResult',
    'GetPoolStartTaskResourceFileResult',
    'GetPoolStartTaskUserIdentityResult',
    'GetPoolStartTaskUserIdentityAutoUserResult',
    'GetPoolStorageImageReferenceResult',
]

@pulumi.output_type
class AccountKeyVaultReference(dict):
    def __init__(__self__, *,
                 id: str,
                 url: str):
        """
        :param str id: The Azure identifier of the Azure KeyVault to use.
        :param str url: The HTTPS URL of the Azure KeyVault to use.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The Azure identifier of the Azure KeyVault to use.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The HTTPS URL of the Azure KeyVault to use.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class PoolAutoScale(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "evaluationInterval":
            suggest = "evaluation_interval"

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

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

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

    def __init__(__self__, *,
                 formula: str,
                 evaluation_interval: Optional[str] = None):
        """
        :param str formula: The autoscale formula that needs to be used for scaling the Batch pool.
        :param str evaluation_interval: The interval to wait before evaluating if the pool needs to be scaled. Defaults to `PT15M`.
        """
        pulumi.set(__self__, "formula", formula)
        if evaluation_interval is not None:
            pulumi.set(__self__, "evaluation_interval", evaluation_interval)

    @property
    @pulumi.getter
    def formula(self) -> str:
        """
        The autoscale formula that needs to be used for scaling the Batch pool.
        """
        return pulumi.get(self, "formula")

    @property
    @pulumi.getter(name="evaluationInterval")
    def evaluation_interval(self) -> Optional[str]:
        """
        The interval to wait before evaluating if the pool needs to be scaled. Defaults to `PT15M`.
        """
        return pulumi.get(self, "evaluation_interval")


@pulumi.output_type
class PoolCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "storeLocation":
            suggest = "store_location"
        elif key == "storeName":
            suggest = "store_name"

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

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

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

    def __init__(__self__, *,
                 id: str,
                 store_location: str,
                 store_name: Optional[str] = None,
                 visibilities: Optional[Sequence[str]] = None):
        """
        :param str id: The ID of the Batch Certificate to install on the Batch Pool, which must be inside the same Batch Account.
        :param str store_location: The location of the certificate store on the compute node into which to install the certificate. Possible values are `CurrentUser` or `LocalMachine`.
        :param str store_name: The name of the certificate store on the compute node into which to install the certificate. This property is applicable only for pools configured with Windows nodes (that is, created with cloudServiceConfiguration, or with virtualMachineConfiguration using a Windows image reference). Common store names include: `My`, `Root`, `CA`, `Trust`, `Disallowed`, `TrustedPeople`, `TrustedPublisher`, `AuthRoot`, `AddressBook`, but any custom store name can also be used. The default value is `My`.
        :param Sequence[str] visibilities: Which user accounts on the compute node should have access to the private data of the certificate.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "store_location", store_location)
        if store_name is not None:
            pulumi.set(__self__, "store_name", store_name)
        if visibilities is not None:
            pulumi.set(__self__, "visibilities", visibilities)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Batch Certificate to install on the Batch Pool, which must be inside the same Batch Account.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="storeLocation")
    def store_location(self) -> str:
        """
        The location of the certificate store on the compute node into which to install the certificate. Possible values are `CurrentUser` or `LocalMachine`.
        """
        return pulumi.get(self, "store_location")

    @property
    @pulumi.getter(name="storeName")
    def store_name(self) -> Optional[str]:
        """
        The name of the certificate store on the compute node into which to install the certificate. This property is applicable only for pools configured with Windows nodes (that is, created with cloudServiceConfiguration, or with virtualMachineConfiguration using a Windows image reference). Common store names include: `My`, `Root`, `CA`, `Trust`, `Disallowed`, `TrustedPeople`, `TrustedPublisher`, `AuthRoot`, `AddressBook`, but any custom store name can also be used. The default value is `My`.
        """
        return pulumi.get(self, "store_name")

    @property
    @pulumi.getter
    def visibilities(self) -> Optional[Sequence[str]]:
        """
        Which user accounts on the compute node should have access to the private data of the certificate.
        """
        return pulumi.get(self, "visibilities")


@pulumi.output_type
class PoolContainerConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerImageNames":
            suggest = "container_image_names"
        elif key == "containerRegistries":
            suggest = "container_registries"

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

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

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

    def __init__(__self__, *,
                 container_image_names: Optional[Sequence[str]] = None,
                 container_registries: Optional[Sequence['outputs.PoolContainerConfigurationContainerRegistry']] = None,
                 type: Optional[str] = None):
        """
        :param Sequence[str] container_image_names: A list of container image names to use, as would be specified by `docker pull`.
        :param Sequence['PoolContainerConfigurationContainerRegistryArgs'] container_registries: Additional container registries from which container images can be pulled by the pool's VMs.
        :param str type: The type of container configuration. Possible value is `DockerCompatible`.
        """
        if container_image_names is not None:
            pulumi.set(__self__, "container_image_names", container_image_names)
        if container_registries is not None:
            pulumi.set(__self__, "container_registries", container_registries)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="containerImageNames")
    def container_image_names(self) -> Optional[Sequence[str]]:
        """
        A list of container image names to use, as would be specified by `docker pull`.
        """
        return pulumi.get(self, "container_image_names")

    @property
    @pulumi.getter(name="containerRegistries")
    def container_registries(self) -> Optional[Sequence['outputs.PoolContainerConfigurationContainerRegistry']]:
        """
        Additional container registries from which container images can be pulled by the pool's VMs.
        """
        return pulumi.get(self, "container_registries")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of container configuration. Possible value is `DockerCompatible`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class PoolContainerConfigurationContainerRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "registryServer":
            suggest = "registry_server"
        elif key == "userName":
            suggest = "user_name"

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

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

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

    def __init__(__self__, *,
                 password: str,
                 registry_server: str,
                 user_name: str):
        """
        :param str password: The password to log into the registry server. Changing this forces a new resource to be created.
        :param str registry_server: The container registry URL. The default is "docker.io". Changing this forces a new resource to be created.
        :param str user_name: The user name to log into the registry server. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "registry_server", registry_server)
        pulumi.set(__self__, "user_name", user_name)

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

    @property
    @pulumi.getter(name="registryServer")
    def registry_server(self) -> str:
        """
        The container registry URL. The default is "docker.io". Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "registry_server")

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> str:
        """
        The user name to log into the registry server. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "user_name")


@pulumi.output_type
class PoolFixedScale(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resizeTimeout":
            suggest = "resize_timeout"
        elif key == "targetDedicatedNodes":
            suggest = "target_dedicated_nodes"
        elif key == "targetLowPriorityNodes":
            suggest = "target_low_priority_nodes"

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

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

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

    def __init__(__self__, *,
                 resize_timeout: Optional[str] = None,
                 target_dedicated_nodes: Optional[int] = None,
                 target_low_priority_nodes: Optional[int] = None):
        """
        :param str resize_timeout: The timeout for resize operations. Defaults to `PT15M`.
        :param int target_dedicated_nodes: The number of nodes in the Batch pool. Defaults to `1`.
        :param int target_low_priority_nodes: The number of low priority nodes in the Batch pool. Defaults to `0`.
        """
        if resize_timeout is not None:
            pulumi.set(__self__, "resize_timeout", resize_timeout)
        if target_dedicated_nodes is not None:
            pulumi.set(__self__, "target_dedicated_nodes", target_dedicated_nodes)
        if target_low_priority_nodes is not None:
            pulumi.set(__self__, "target_low_priority_nodes", target_low_priority_nodes)

    @property
    @pulumi.getter(name="resizeTimeout")
    def resize_timeout(self) -> Optional[str]:
        """
        The timeout for resize operations. Defaults to `PT15M`.
        """
        return pulumi.get(self, "resize_timeout")

    @property
    @pulumi.getter(name="targetDedicatedNodes")
    def target_dedicated_nodes(self) -> Optional[int]:
        """
        The number of nodes in the Batch pool. Defaults to `1`.
        """
        return pulumi.get(self, "target_dedicated_nodes")

    @property
    @pulumi.getter(name="targetLowPriorityNodes")
    def target_low_priority_nodes(self) -> Optional[int]:
        """
        The number of low priority nodes in the Batch pool. Defaults to `0`.
        """
        return pulumi.get(self, "target_low_priority_nodes")


@pulumi.output_type
class PoolNetworkConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"
        elif key == "endpointConfigurations":
            suggest = "endpoint_configurations"
        elif key == "publicAddressProvisioningType":
            suggest = "public_address_provisioning_type"
        elif key == "publicIps":
            suggest = "public_ips"

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

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

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

    def __init__(__self__, *,
                 subnet_id: str,
                 endpoint_configurations: Optional[Sequence['outputs.PoolNetworkConfigurationEndpointConfiguration']] = None,
                 public_address_provisioning_type: Optional[str] = None,
                 public_ips: Optional[Sequence[str]] = None):
        """
        :param str subnet_id: The ARM resource identifier of the virtual network subnet which the compute nodes of the pool will join. Changing this forces a new resource to be created.
        :param Sequence['PoolNetworkConfigurationEndpointConfigurationArgs'] endpoint_configurations: A list of inbound NAT pools that can be used to address specific ports on an individual compute node externally. Set as documented in the inbound_nat_pools block below. Changing this forces a new resource to be created.
        :param str public_address_provisioning_type: Type of public IP address provisioning. Supported values are `BatchManaged`, `UserManaged` and `NoPublicIPAddresses`.
        :param Sequence[str] public_ips: A list of public ip ids that will be allocated to nodes. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "subnet_id", subnet_id)
        if endpoint_configurations is not None:
            pulumi.set(__self__, "endpoint_configurations", endpoint_configurations)
        if public_address_provisioning_type is not None:
            pulumi.set(__self__, "public_address_provisioning_type", public_address_provisioning_type)
        if public_ips is not None:
            pulumi.set(__self__, "public_ips", public_ips)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ARM resource identifier of the virtual network subnet which the compute nodes of the pool will join. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="endpointConfigurations")
    def endpoint_configurations(self) -> Optional[Sequence['outputs.PoolNetworkConfigurationEndpointConfiguration']]:
        """
        A list of inbound NAT pools that can be used to address specific ports on an individual compute node externally. Set as documented in the inbound_nat_pools block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "endpoint_configurations")

    @property
    @pulumi.getter(name="publicAddressProvisioningType")
    def public_address_provisioning_type(self) -> Optional[str]:
        """
        Type of public IP address provisioning. Supported values are `BatchManaged`, `UserManaged` and `NoPublicIPAddresses`.
        """
        return pulumi.get(self, "public_address_provisioning_type")

    @property
    @pulumi.getter(name="publicIps")
    def public_ips(self) -> Optional[Sequence[str]]:
        """
        A list of public ip ids that will be allocated to nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "public_ips")


@pulumi.output_type
class PoolNetworkConfigurationEndpointConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendPort":
            suggest = "backend_port"
        elif key == "frontendPortRange":
            suggest = "frontend_port_range"
        elif key == "networkSecurityGroupRules":
            suggest = "network_security_group_rules"

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

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

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

    def __init__(__self__, *,
                 backend_port: int,
                 frontend_port_range: str,
                 name: str,
                 protocol: str,
                 network_security_group_rules: Optional[Sequence['outputs.PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule']] = None):
        """
        :param int backend_port: The port number on the compute node. Acceptable values are between `1` and `65535` except for `29876`, `29877` as these are reserved. Changing this forces a new resource to be created.
        :param str frontend_port_range: The range of external ports that will be used to provide inbound access to the backendPort on individual compute nodes in the format of `1000-1100`. Acceptable values range between `1` and `65534` except ports from `50000` to `55000` which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. Values must be a range of at least `100` nodes. Changing this forces a new resource to be created.
        :param str name: The name of the endpoint. The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters. Changing this forces a new resource to be created.
        :param str protocol: The protocol of the endpoint. Acceptable values are `TCP` and `UDP`. Changing this forces a new resource to be created.
        :param Sequence['PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs'] network_security_group_rules: A list of network security group rules that will be applied to the endpoint. The maximum number of rules that can be specified across all the endpoints on a Batch pool is `25`. If no network security group rules are specified, a default rule will be created to allow inbound access to the specified backendPort. Set as documented in the network_security_group_rules block below. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "backend_port", backend_port)
        pulumi.set(__self__, "frontend_port_range", frontend_port_range)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocol", protocol)
        if network_security_group_rules is not None:
            pulumi.set(__self__, "network_security_group_rules", network_security_group_rules)

    @property
    @pulumi.getter(name="backendPort")
    def backend_port(self) -> int:
        """
        The port number on the compute node. Acceptable values are between `1` and `65535` except for `29876`, `29877` as these are reserved. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "backend_port")

    @property
    @pulumi.getter(name="frontendPortRange")
    def frontend_port_range(self) -> str:
        """
        The range of external ports that will be used to provide inbound access to the backendPort on individual compute nodes in the format of `1000-1100`. Acceptable values range between `1` and `65534` except ports from `50000` to `55000` which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. Values must be a range of at least `100` nodes. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "frontend_port_range")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the endpoint. The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol of the endpoint. Acceptable values are `TCP` and `UDP`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="networkSecurityGroupRules")
    def network_security_group_rules(self) -> Optional[Sequence['outputs.PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule']]:
        """
        A list of network security group rules that will be applied to the endpoint. The maximum number of rules that can be specified across all the endpoints on a Batch pool is `25`. If no network security group rules are specified, a default rule will be created to allow inbound access to the specified backendPort. Set as documented in the network_security_group_rules block below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "network_security_group_rules")


@pulumi.output_type
class PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceAddressPrefix":
            suggest = "source_address_prefix"

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

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

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

    def __init__(__self__, *,
                 access: str,
                 priority: int,
                 source_address_prefix: str):
        """
        :param str access: The action that should be taken for a specified IP address, subnet range or tag. Acceptable values are `Allow` and `Deny`. Changing this forces a new resource to be created.
        :param int priority: The priority for this rule. The value must be at least `150`. Changing this forces a new resource to be created.
        :param str source_address_prefix: The source address prefix or tag to match for the rule. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "source_address_prefix", source_address_prefix)

    @property
    @pulumi.getter
    def access(self) -> str:
        """
        The action that should be taken for a specified IP address, subnet range or tag. Acceptable values are `Allow` and `Deny`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "access")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        The priority for this rule. The value must be at least `150`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="sourceAddressPrefix")
    def source_address_prefix(self) -> str:
        """
        The source address prefix or tag to match for the rule. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "source_address_prefix")


@pulumi.output_type
class PoolStartTask(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commandLine":
            suggest = "command_line"
        elif key == "userIdentity":
            suggest = "user_identity"
        elif key == "maxTaskRetryCount":
            suggest = "max_task_retry_count"
        elif key == "resourceFiles":
            suggest = "resource_files"
        elif key == "waitForSuccess":
            suggest = "wait_for_success"

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

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

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

    def __init__(__self__, *,
                 command_line: str,
                 user_identity: 'outputs.PoolStartTaskUserIdentity',
                 environment: Optional[Mapping[str, str]] = None,
                 max_task_retry_count: Optional[int] = None,
                 resource_files: Optional[Sequence['outputs.PoolStartTaskResourceFile']] = None,
                 wait_for_success: Optional[bool] = None):
        """
        :param str command_line: The command line executed by the start task.
        :param 'PoolStartTaskUserIdentityArgs' user_identity: A `user_identity` block that describes the user identity under which the start task runs.
        :param Mapping[str, str] environment: A map of strings (key,value) that represents the environment variables to set in the start task.
        :param int max_task_retry_count: The number of retry count. Defaults to `1`.
        :param Sequence['PoolStartTaskResourceFileArgs'] resource_files: One or more `resource_file` blocks that describe the files to be downloaded to a compute node.
        :param bool wait_for_success: A flag that indicates if the Batch pool should wait for the start task to be completed. Default to `false`.
        """
        pulumi.set(__self__, "command_line", command_line)
        pulumi.set(__self__, "user_identity", user_identity)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if max_task_retry_count is not None:
            pulumi.set(__self__, "max_task_retry_count", max_task_retry_count)
        if resource_files is not None:
            pulumi.set(__self__, "resource_files", resource_files)
        if wait_for_success is not None:
            pulumi.set(__self__, "wait_for_success", wait_for_success)

    @property
    @pulumi.getter(name="commandLine")
    def command_line(self) -> str:
        """
        The command line executed by the start task.
        """
        return pulumi.get(self, "command_line")

    @property
    @pulumi.getter(name="userIdentity")
    def user_identity(self) -> 'outputs.PoolStartTaskUserIdentity':
        """
        A `user_identity` block that describes the user identity under which the start task runs.
        """
        return pulumi.get(self, "user_identity")

    @property
    @pulumi.getter
    def environment(self) -> Optional[Mapping[str, str]]:
        """
        A map of strings (key,value) that represents the environment variables to set in the start task.
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="maxTaskRetryCount")
    def max_task_retry_count(self) -> Optional[int]:
        """
        The number of retry count. Defaults to `1`.
        """
        return pulumi.get(self, "max_task_retry_count")

    @property
    @pulumi.getter(name="resourceFiles")
    def resource_files(self) -> Optional[Sequence['outputs.PoolStartTaskResourceFile']]:
        """
        One or more `resource_file` blocks that describe the files to be downloaded to a compute node.
        """
        return pulumi.get(self, "resource_files")

    @property
    @pulumi.getter(name="waitForSuccess")
    def wait_for_success(self) -> Optional[bool]:
        """
        A flag that indicates if the Batch pool should wait for the start task to be completed. Default to `false`.
        """
        return pulumi.get(self, "wait_for_success")


@pulumi.output_type
class PoolStartTaskResourceFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoStorageContainerName":
            suggest = "auto_storage_container_name"
        elif key == "blobPrefix":
            suggest = "blob_prefix"
        elif key == "fileMode":
            suggest = "file_mode"
        elif key == "filePath":
            suggest = "file_path"
        elif key == "httpUrl":
            suggest = "http_url"
        elif key == "storageContainerUrl":
            suggest = "storage_container_url"

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

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

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

    def __init__(__self__, *,
                 auto_storage_container_name: Optional[str] = None,
                 blob_prefix: Optional[str] = None,
                 file_mode: Optional[str] = None,
                 file_path: Optional[str] = None,
                 http_url: Optional[str] = None,
                 storage_container_url: Optional[str] = None):
        """
        :param str auto_storage_container_name: The storage container name in the auto storage account.
        :param str blob_prefix: The blob prefix to use when downloading blobs from an Azure Storage container. Only the blobs whose names begin with the specified prefix will be downloaded. The property is valid only when `auto_storage_container_name` or `storage_container_url` is used. This prefix can be a partial filename or a subdirectory. If a prefix is not specified, all the files in the container will be downloaded.
        :param str file_mode: The file permission mode represented as a string in octal format (e.g. `"0644"`). This property applies only to files being downloaded to Linux compute nodes. It will be ignored if it is specified for a `resource_file` which will be downloaded to a Windows node. If this property is not specified for a Linux node, then a default value of 0770 is applied to the file.
        :param str file_path: The location on the compute node to which to download the file, relative to the task's working directory. If the `http_url` property is specified, the `file_path` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `auto_storage_container_name` or `storage_container_url` property is specified, `file_path` is optional and is the directory to download the files to. In the case where `file_path` is used as a directory, any directory structure already associated with the input data will be retained in full and appended to the specified filePath directory. The specified relative path cannot break out of the task's working directory (for example by using '..').
        :param str http_url: The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read permissions on the blob, or set the ACL for the blob or its container to allow public access.
        :param str storage_container_url: The URL of the blob container within Azure Blob Storage. This URL must be readable and listable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read and list permissions on the blob, or set the ACL for the blob or its container to allow public access.
        """
        if auto_storage_container_name is not None:
            pulumi.set(__self__, "auto_storage_container_name", auto_storage_container_name)
        if blob_prefix is not None:
            pulumi.set(__self__, "blob_prefix", blob_prefix)
        if file_mode is not None:
            pulumi.set(__self__, "file_mode", file_mode)
        if file_path is not None:
            pulumi.set(__self__, "file_path", file_path)
        if http_url is not None:
            pulumi.set(__self__, "http_url", http_url)
        if storage_container_url is not None:
            pulumi.set(__self__, "storage_container_url", storage_container_url)

    @property
    @pulumi.getter(name="autoStorageContainerName")
    def auto_storage_container_name(self) -> Optional[str]:
        """
        The storage container name in the auto storage account.
        """
        return pulumi.get(self, "auto_storage_container_name")

    @property
    @pulumi.getter(name="blobPrefix")
    def blob_prefix(self) -> Optional[str]:
        """
        The blob prefix to use when downloading blobs from an Azure Storage container. Only the blobs whose names begin with the specified prefix will be downloaded. The property is valid only when `auto_storage_container_name` or `storage_container_url` is used. This prefix can be a partial filename or a subdirectory. If a prefix is not specified, all the files in the container will be downloaded.
        """
        return pulumi.get(self, "blob_prefix")

    @property
    @pulumi.getter(name="fileMode")
    def file_mode(self) -> Optional[str]:
        """
        The file permission mode represented as a string in octal format (e.g. `"0644"`). This property applies only to files being downloaded to Linux compute nodes. It will be ignored if it is specified for a `resource_file` which will be downloaded to a Windows node. If this property is not specified for a Linux node, then a default value of 0770 is applied to the file.
        """
        return pulumi.get(self, "file_mode")

    @property
    @pulumi.getter(name="filePath")
    def file_path(self) -> Optional[str]:
        """
        The location on the compute node to which to download the file, relative to the task's working directory. If the `http_url` property is specified, the `file_path` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `auto_storage_container_name` or `storage_container_url` property is specified, `file_path` is optional and is the directory to download the files to. In the case where `file_path` is used as a directory, any directory structure already associated with the input data will be retained in full and appended to the specified filePath directory. The specified relative path cannot break out of the task's working directory (for example by using '..').
        """
        return pulumi.get(self, "file_path")

    @property
    @pulumi.getter(name="httpUrl")
    def http_url(self) -> Optional[str]:
        """
        The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read permissions on the blob, or set the ACL for the blob or its container to allow public access.
        """
        return pulumi.get(self, "http_url")

    @property
    @pulumi.getter(name="storageContainerUrl")
    def storage_container_url(self) -> Optional[str]:
        """
        The URL of the blob container within Azure Blob Storage. This URL must be readable and listable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read and list permissions on the blob, or set the ACL for the blob or its container to allow public access.
        """
        return pulumi.get(self, "storage_container_url")


@pulumi.output_type
class PoolStartTaskUserIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoUser":
            suggest = "auto_user"
        elif key == "userName":
            suggest = "user_name"

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

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

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

    def __init__(__self__, *,
                 auto_user: Optional['outputs.PoolStartTaskUserIdentityAutoUser'] = None,
                 user_name: Optional[str] = None):
        """
        :param 'PoolStartTaskUserIdentityAutoUserArgs' auto_user: A `auto_user` block that describes the user identity under which the start task runs.
        :param str user_name: The username to be used by the Batch pool start task.
        """
        if auto_user is not None:
            pulumi.set(__self__, "auto_user", auto_user)
        if user_name is not None:
            pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter(name="autoUser")
    def auto_user(self) -> Optional['outputs.PoolStartTaskUserIdentityAutoUser']:
        """
        A `auto_user` block that describes the user identity under which the start task runs.
        """
        return pulumi.get(self, "auto_user")

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> Optional[str]:
        """
        The username to be used by the Batch pool start task.
        """
        return pulumi.get(self, "user_name")


@pulumi.output_type
class PoolStartTaskUserIdentityAutoUser(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "elevationLevel":
            suggest = "elevation_level"

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

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

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

    def __init__(__self__, *,
                 elevation_level: Optional[str] = None,
                 scope: Optional[str] = None):
        """
        :param str elevation_level: The elevation level of the user identity under which the start task runs. Possible values are `Admin` or `NonAdmin`. Defaults to `NonAdmin`.
        :param str scope: The scope of the user identity under which the start task runs. Possible values are `Task` or `Pool`. Defaults to `Task`.
        """
        if elevation_level is not None:
            pulumi.set(__self__, "elevation_level", elevation_level)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter(name="elevationLevel")
    def elevation_level(self) -> Optional[str]:
        """
        The elevation level of the user identity under which the start task runs. Possible values are `Admin` or `NonAdmin`. Defaults to `NonAdmin`.
        """
        return pulumi.get(self, "elevation_level")

    @property
    @pulumi.getter
    def scope(self) -> Optional[str]:
        """
        The scope of the user identity under which the start task runs. Possible values are `Task` or `Pool`. Defaults to `Task`.
        """
        return pulumi.get(self, "scope")


@pulumi.output_type
class PoolStorageImageReference(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 offer: Optional[str] = None,
                 publisher: Optional[str] = None,
                 sku: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str id: Specifies the ID of the Custom Image which the virtual machines should be created from. Changing this forces a new resource to be created. See [official documentation](https://docs.microsoft.com/en-us/azure/batch/batch-custom-images) for more details.
               ---
        :param str offer: Specifies the offer of the image used to create the virtual machines. Changing this forces a new resource to be created.
        :param str publisher: Specifies the publisher of the image used to create the virtual machines. Changing this forces a new resource to be created.
        :param str sku: Specifies the SKU of the image used to create the virtual machines. Changing this forces a new resource to be created.
        :param str version: Specifies the version of the image used to create the virtual machines. Changing this forces a new resource to be created.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if offer is not None:
            pulumi.set(__self__, "offer", offer)
        if publisher is not None:
            pulumi.set(__self__, "publisher", publisher)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Specifies the ID of the Custom Image which the virtual machines should be created from. Changing this forces a new resource to be created. See [official documentation](https://docs.microsoft.com/en-us/azure/batch/batch-custom-images) for more details.
        ---
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def offer(self) -> Optional[str]:
        """
        Specifies the offer of the image used to create the virtual machines. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "offer")

    @property
    @pulumi.getter
    def publisher(self) -> Optional[str]:
        """
        Specifies the publisher of the image used to create the virtual machines. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "publisher")

    @property
    @pulumi.getter
    def sku(self) -> Optional[str]:
        """
        Specifies the SKU of the image used to create the virtual machines. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "sku")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Specifies the version of the image used to create the virtual machines. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetAccountKeyVaultReferenceResult(dict):
    def __init__(__self__, *,
                 id: str,
                 url: str):
        """
        :param str id: The Azure identifier of the Azure KeyVault reference.
        :param str url: The HTTPS URL of the Azure KeyVault reference.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The Azure identifier of the Azure KeyVault reference.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The HTTPS URL of the Azure KeyVault reference.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetPoolAutoScaleResult(dict):
    def __init__(__self__, *,
                 evaluation_interval: str,
                 formula: str):
        """
        :param str evaluation_interval: The interval to wait before evaluating if the pool needs to be scaled.
        :param str formula: The autoscale formula that needs to be used for scaling the Batch pool.
        """
        pulumi.set(__self__, "evaluation_interval", evaluation_interval)
        pulumi.set(__self__, "formula", formula)

    @property
    @pulumi.getter(name="evaluationInterval")
    def evaluation_interval(self) -> str:
        """
        The interval to wait before evaluating if the pool needs to be scaled.
        """
        return pulumi.get(self, "evaluation_interval")

    @property
    @pulumi.getter
    def formula(self) -> str:
        """
        The autoscale formula that needs to be used for scaling the Batch pool.
        """
        return pulumi.get(self, "formula")


@pulumi.output_type
class GetPoolCertificateResult(dict):
    def __init__(__self__, *,
                 id: str,
                 store_location: str,
                 store_name: Optional[str] = None,
                 visibilities: Optional[Sequence[str]] = None):
        """
        :param str id: The fully qualified ID of the certificate installed on the pool.
        :param str store_location: The location of the certificate store on the compute node into which the certificate is installed, either `CurrentUser` or `LocalMachine`.
        :param str store_name: The name of the certificate store on the compute node into which the certificate is installed.
        :param Sequence[str] visibilities: Which user accounts on the compute node have access to the private data of the certificate.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "store_location", store_location)
        if store_name is not None:
            pulumi.set(__self__, "store_name", store_name)
        if visibilities is not None:
            pulumi.set(__self__, "visibilities", visibilities)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The fully qualified ID of the certificate installed on the pool.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="storeLocation")
    def store_location(self) -> str:
        """
        The location of the certificate store on the compute node into which the certificate is installed, either `CurrentUser` or `LocalMachine`.
        """
        return pulumi.get(self, "store_location")

    @property
    @pulumi.getter(name="storeName")
    def store_name(self) -> Optional[str]:
        """
        The name of the certificate store on the compute node into which the certificate is installed.
        """
        return pulumi.get(self, "store_name")

    @property
    @pulumi.getter
    def visibilities(self) -> Optional[Sequence[str]]:
        """
        Which user accounts on the compute node have access to the private data of the certificate.
        """
        return pulumi.get(self, "visibilities")


@pulumi.output_type
class GetPoolContainerConfigurationResult(dict):
    def __init__(__self__, *,
                 container_image_names: Sequence[str],
                 container_registries: Sequence['outputs.GetPoolContainerConfigurationContainerRegistryResult'],
                 type: str):
        """
        :param Sequence[str] container_image_names: A list of container image names to use, as would be specified by `docker pull`.
        :param Sequence['GetPoolContainerConfigurationContainerRegistryArgs'] container_registries: Additional container registries from which container images can be pulled by the pool's VMs.
        :param str type: The type of container configuration.
        """
        pulumi.set(__self__, "container_image_names", container_image_names)
        pulumi.set(__self__, "container_registries", container_registries)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="containerImageNames")
    def container_image_names(self) -> Sequence[str]:
        """
        A list of container image names to use, as would be specified by `docker pull`.
        """
        return pulumi.get(self, "container_image_names")

    @property
    @pulumi.getter(name="containerRegistries")
    def container_registries(self) -> Sequence['outputs.GetPoolContainerConfigurationContainerRegistryResult']:
        """
        Additional container registries from which container images can be pulled by the pool's VMs.
        """
        return pulumi.get(self, "container_registries")

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


@pulumi.output_type
class GetPoolContainerConfigurationContainerRegistryResult(dict):
    def __init__(__self__, *,
                 password: str,
                 registry_server: str,
                 user_name: str):
        """
        :param str password: The password to log into the registry server.
        :param str registry_server: The container registry URL. The default is "docker.io".
        :param str user_name: The user name to log into the registry server.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "registry_server", registry_server)
        pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password to log into the registry server.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="registryServer")
    def registry_server(self) -> str:
        """
        The container registry URL. The default is "docker.io".
        """
        return pulumi.get(self, "registry_server")

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> str:
        """
        The user name to log into the registry server.
        """
        return pulumi.get(self, "user_name")


@pulumi.output_type
class GetPoolFixedScaleResult(dict):
    def __init__(__self__, *,
                 resize_timeout: str,
                 target_dedicated_nodes: int,
                 target_low_priority_nodes: int):
        """
        :param str resize_timeout: The timeout for resize operations.
        :param int target_dedicated_nodes: The number of nodes in the Batch pool.
        :param int target_low_priority_nodes: The number of low priority nodes in the Batch pool.
        """
        pulumi.set(__self__, "resize_timeout", resize_timeout)
        pulumi.set(__self__, "target_dedicated_nodes", target_dedicated_nodes)
        pulumi.set(__self__, "target_low_priority_nodes", target_low_priority_nodes)

    @property
    @pulumi.getter(name="resizeTimeout")
    def resize_timeout(self) -> str:
        """
        The timeout for resize operations.
        """
        return pulumi.get(self, "resize_timeout")

    @property
    @pulumi.getter(name="targetDedicatedNodes")
    def target_dedicated_nodes(self) -> int:
        """
        The number of nodes in the Batch pool.
        """
        return pulumi.get(self, "target_dedicated_nodes")

    @property
    @pulumi.getter(name="targetLowPriorityNodes")
    def target_low_priority_nodes(self) -> int:
        """
        The number of low priority nodes in the Batch pool.
        """
        return pulumi.get(self, "target_low_priority_nodes")


@pulumi.output_type
class GetPoolNetworkConfigurationResult(dict):
    def __init__(__self__, *,
                 endpoint_configuration: 'outputs.GetPoolNetworkConfigurationEndpointConfigurationResult',
                 subnet_id: str):
        """
        :param 'GetPoolNetworkConfigurationEndpointConfigurationArgs' endpoint_configuration: The inbound NAT pools that are used to address specific ports on the individual compute node externally.
        :param str subnet_id: The ARM resource identifier of the virtual network subnet which the compute nodes of the pool are joined too.
        """
        pulumi.set(__self__, "endpoint_configuration", endpoint_configuration)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="endpointConfiguration")
    def endpoint_configuration(self) -> 'outputs.GetPoolNetworkConfigurationEndpointConfigurationResult':
        """
        The inbound NAT pools that are used to address specific ports on the individual compute node externally.
        """
        return pulumi.get(self, "endpoint_configuration")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ARM resource identifier of the virtual network subnet which the compute nodes of the pool are joined too.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetPoolNetworkConfigurationEndpointConfigurationResult(dict):
    def __init__(__self__, *,
                 backend_port: int,
                 frontend_port_range: str,
                 name: str,
                 network_security_group_rules: Sequence['outputs.GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleResult'],
                 protocol: str):
        """
        :param int backend_port: The port number on the compute node.
        :param str frontend_port_range: The range of external ports that are used to provide inbound access to the backendPort on the individual compute nodes in the format of `1000-1100`.
        :param str name: The name of the endpoint.
        :param Sequence['GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs'] network_security_group_rules: The list of network security group rules that are applied to the endpoint.
        :param str protocol: The protocol of the endpoint.
        """
        pulumi.set(__self__, "backend_port", backend_port)
        pulumi.set(__self__, "frontend_port_range", frontend_port_range)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_security_group_rules", network_security_group_rules)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter(name="backendPort")
    def backend_port(self) -> int:
        """
        The port number on the compute node.
        """
        return pulumi.get(self, "backend_port")

    @property
    @pulumi.getter(name="frontendPortRange")
    def frontend_port_range(self) -> str:
        """
        The range of external ports that are used to provide inbound access to the backendPort on the individual compute nodes in the format of `1000-1100`.
        """
        return pulumi.get(self, "frontend_port_range")

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

    @property
    @pulumi.getter(name="networkSecurityGroupRules")
    def network_security_group_rules(self) -> Sequence['outputs.GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleResult']:
        """
        The list of network security group rules that are applied to the endpoint.
        """
        return pulumi.get(self, "network_security_group_rules")

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


@pulumi.output_type
class GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleResult(dict):
    def __init__(__self__, *,
                 access: str,
                 priority: int,
                 source_address_prefix: str):
        """
        :param str access: The action that should be taken for a specified IP address, subnet range or tag.
        :param int priority: The priority for this rule.
        :param str source_address_prefix: The source address prefix or tag to match for the rule.
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "source_address_prefix", source_address_prefix)

    @property
    @pulumi.getter
    def access(self) -> str:
        """
        The action that should be taken for a specified IP address, subnet range or tag.
        """
        return pulumi.get(self, "access")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        The priority for this rule.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="sourceAddressPrefix")
    def source_address_prefix(self) -> str:
        """
        The source address prefix or tag to match for the rule.
        """
        return pulumi.get(self, "source_address_prefix")


@pulumi.output_type
class GetPoolStartTaskResult(dict):
    def __init__(__self__, *,
                 command_line: str,
                 resource_files: Sequence['outputs.GetPoolStartTaskResourceFileResult'],
                 user_identities: Sequence['outputs.GetPoolStartTaskUserIdentityResult'],
                 environment: Optional[Mapping[str, str]] = None,
                 max_task_retry_count: Optional[int] = None,
                 wait_for_success: Optional[bool] = None):
        """
        :param str command_line: The command line executed by the start task.
        :param Sequence['GetPoolStartTaskResourceFileArgs'] resource_files: One or more `resource_file` blocks that describe the files to be downloaded to a compute node.
        :param Sequence['GetPoolStartTaskUserIdentityArgs'] user_identities: A `user_identity` block that describes the user identity under which the start task runs.
        :param Mapping[str, str] environment: A map of strings (key,value) that represents the environment variables to set in the start task.
        :param int max_task_retry_count: The number of retry count.
        :param bool wait_for_success: A flag that indicates if the Batch pool should wait for the start task to be completed.
        """
        pulumi.set(__self__, "command_line", command_line)
        pulumi.set(__self__, "resource_files", resource_files)
        pulumi.set(__self__, "user_identities", user_identities)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if max_task_retry_count is not None:
            pulumi.set(__self__, "max_task_retry_count", max_task_retry_count)
        if wait_for_success is not None:
            pulumi.set(__self__, "wait_for_success", wait_for_success)

    @property
    @pulumi.getter(name="commandLine")
    def command_line(self) -> str:
        """
        The command line executed by the start task.
        """
        return pulumi.get(self, "command_line")

    @property
    @pulumi.getter(name="resourceFiles")
    def resource_files(self) -> Sequence['outputs.GetPoolStartTaskResourceFileResult']:
        """
        One or more `resource_file` blocks that describe the files to be downloaded to a compute node.
        """
        return pulumi.get(self, "resource_files")

    @property
    @pulumi.getter(name="userIdentities")
    def user_identities(self) -> Sequence['outputs.GetPoolStartTaskUserIdentityResult']:
        """
        A `user_identity` block that describes the user identity under which the start task runs.
        """
        return pulumi.get(self, "user_identities")

    @property
    @pulumi.getter
    def environment(self) -> Optional[Mapping[str, str]]:
        """
        A map of strings (key,value) that represents the environment variables to set in the start task.
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="maxTaskRetryCount")
    def max_task_retry_count(self) -> Optional[int]:
        """
        The number of retry count.
        """
        return pulumi.get(self, "max_task_retry_count")

    @property
    @pulumi.getter(name="waitForSuccess")
    def wait_for_success(self) -> Optional[bool]:
        """
        A flag that indicates if the Batch pool should wait for the start task to be completed.
        """
        return pulumi.get(self, "wait_for_success")


@pulumi.output_type
class GetPoolStartTaskResourceFileResult(dict):
    def __init__(__self__, *,
                 auto_storage_container_name: str,
                 blob_prefix: str,
                 file_mode: str,
                 file_path: str,
                 http_url: str,
                 storage_container_url: str):
        """
        :param str auto_storage_container_name: The storage container name in the auto storage account.
        :param str blob_prefix: The blob prefix used when downloading blobs from an Azure Storage container.
        :param str file_mode: The file permission mode attribute represented as a string in octal format (e.g. `"0644"`).
        :param str file_path: The location on the compute node to which to download the file, relative to the task's working directory. If the `http_url` property is specified, the `file_path` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `auto_storage_container_name` or `storage_container_url` property is specified.
        :param str http_url: The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access.
        :param str storage_container_url: The URL of the blob container within Azure Blob Storage.
        """
        pulumi.set(__self__, "auto_storage_container_name", auto_storage_container_name)
        pulumi.set(__self__, "blob_prefix", blob_prefix)
        pulumi.set(__self__, "file_mode", file_mode)
        pulumi.set(__self__, "file_path", file_path)
        pulumi.set(__self__, "http_url", http_url)
        pulumi.set(__self__, "storage_container_url", storage_container_url)

    @property
    @pulumi.getter(name="autoStorageContainerName")
    def auto_storage_container_name(self) -> str:
        """
        The storage container name in the auto storage account.
        """
        return pulumi.get(self, "auto_storage_container_name")

    @property
    @pulumi.getter(name="blobPrefix")
    def blob_prefix(self) -> str:
        """
        The blob prefix used when downloading blobs from an Azure Storage container.
        """
        return pulumi.get(self, "blob_prefix")

    @property
    @pulumi.getter(name="fileMode")
    def file_mode(self) -> str:
        """
        The file permission mode attribute represented as a string in octal format (e.g. `"0644"`).
        """
        return pulumi.get(self, "file_mode")

    @property
    @pulumi.getter(name="filePath")
    def file_path(self) -> str:
        """
        The location on the compute node to which to download the file, relative to the task's working directory. If the `http_url` property is specified, the `file_path` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `auto_storage_container_name` or `storage_container_url` property is specified.
        """
        return pulumi.get(self, "file_path")

    @property
    @pulumi.getter(name="httpUrl")
    def http_url(self) -> str:
        """
        The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access.
        """
        return pulumi.get(self, "http_url")

    @property
    @pulumi.getter(name="storageContainerUrl")
    def storage_container_url(self) -> str:
        """
        The URL of the blob container within Azure Blob Storage.
        """
        return pulumi.get(self, "storage_container_url")


@pulumi.output_type
class GetPoolStartTaskUserIdentityResult(dict):
    def __init__(__self__, *,
                 auto_users: Sequence['outputs.GetPoolStartTaskUserIdentityAutoUserResult'],
                 user_name: str):
        """
        :param Sequence['GetPoolStartTaskUserIdentityAutoUserArgs'] auto_users: A `auto_user` block that describes the user identity under which the start task runs.
        :param str user_name: The user name to log into the registry server.
        """
        pulumi.set(__self__, "auto_users", auto_users)
        pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter(name="autoUsers")
    def auto_users(self) -> Sequence['outputs.GetPoolStartTaskUserIdentityAutoUserResult']:
        """
        A `auto_user` block that describes the user identity under which the start task runs.
        """
        return pulumi.get(self, "auto_users")

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> str:
        """
        The user name to log into the registry server.
        """
        return pulumi.get(self, "user_name")


@pulumi.output_type
class GetPoolStartTaskUserIdentityAutoUserResult(dict):
    def __init__(__self__, *,
                 elevation_level: str,
                 scope: str):
        """
        :param str elevation_level: The elevation level of the user identity under which the start task runs.
        :param str scope: The scope of the user identity under which the start task runs.
        """
        pulumi.set(__self__, "elevation_level", elevation_level)
        pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter(name="elevationLevel")
    def elevation_level(self) -> str:
        """
        The elevation level of the user identity under which the start task runs.
        """
        return pulumi.get(self, "elevation_level")

    @property
    @pulumi.getter
    def scope(self) -> str:
        """
        The scope of the user identity under which the start task runs.
        """
        return pulumi.get(self, "scope")


@pulumi.output_type
class GetPoolStorageImageReferenceResult(dict):
    def __init__(__self__, *,
                 id: str,
                 offer: str,
                 publisher: str,
                 sku: str,
                 version: str):
        """
        :param str id: The fully qualified ID of the certificate installed on the pool.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "offer", offer)
        pulumi.set(__self__, "publisher", publisher)
        pulumi.set(__self__, "sku", sku)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The fully qualified ID of the certificate installed on the pool.
        """
        return pulumi.get(self, "id")

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

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

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

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


