# 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 copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'LabAutoShutdown',
    'LabConnectionSetting',
    'LabNetwork',
    'LabRoster',
    'LabSecurity',
    'LabVirtualMachine',
    'LabVirtualMachineAdminUser',
    'LabVirtualMachineImageReference',
    'LabVirtualMachineNonAdminUser',
    'LabVirtualMachineSku',
    'ScheduleRecurrence',
    'ServicePlanDefaultAutoShutdown',
    'ServicePlanDefaultConnection',
    'ServicePlanSupport',
]

@pulumi.output_type
class LabAutoShutdown(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disconnectDelay":
            suggest = "disconnect_delay"
        elif key == "idleDelay":
            suggest = "idle_delay"
        elif key == "noConnectDelay":
            suggest = "no_connect_delay"
        elif key == "shutdownOnIdle":
            suggest = "shutdown_on_idle"

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

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

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

    def __init__(__self__, *,
                 disconnect_delay: Optional[str] = None,
                 idle_delay: Optional[str] = None,
                 no_connect_delay: Optional[str] = None,
                 shutdown_on_idle: Optional[str] = None):
        """
        :param str disconnect_delay: The amount of time a VM will stay running after a user disconnects if this behavior is enabled. This value must be formatted as an ISO 8601 string.
               
               > **NOTE:** The `shutdownOnDisconnect` is `Disabled` when `disconnect_delay` isn't specified.
        :param str idle_delay: The amount of time a VM will idle before it is shutdown if this behavior is enabled. This value must be formatted as an ISO 8601 string.
        :param str no_connect_delay: The amount of time a VM will stay running before it is shutdown if no connection is made and this behavior is enabled. This value must be formatted as an ISO 8601 string.
               
               > **NOTE:** The `shutdownWhenNotConnected` is `Disabled` when `no_connect_delay` isn't specified.
        :param str shutdown_on_idle: A VM will get shutdown when it has idled for a period of time. Possible values are `LowUsage` and `UserAbsence`.
               
               > **NOTE:** This property is `None` when it isn't specified. No need to set `idle_delay` when `shutdown_on_idle` isn't specified.
        """
        if disconnect_delay is not None:
            pulumi.set(__self__, "disconnect_delay", disconnect_delay)
        if idle_delay is not None:
            pulumi.set(__self__, "idle_delay", idle_delay)
        if no_connect_delay is not None:
            pulumi.set(__self__, "no_connect_delay", no_connect_delay)
        if shutdown_on_idle is not None:
            pulumi.set(__self__, "shutdown_on_idle", shutdown_on_idle)

    @property
    @pulumi.getter(name="disconnectDelay")
    def disconnect_delay(self) -> Optional[str]:
        """
        The amount of time a VM will stay running after a user disconnects if this behavior is enabled. This value must be formatted as an ISO 8601 string.

        > **NOTE:** The `shutdownOnDisconnect` is `Disabled` when `disconnect_delay` isn't specified.
        """
        return pulumi.get(self, "disconnect_delay")

    @property
    @pulumi.getter(name="idleDelay")
    def idle_delay(self) -> Optional[str]:
        """
        The amount of time a VM will idle before it is shutdown if this behavior is enabled. This value must be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "idle_delay")

    @property
    @pulumi.getter(name="noConnectDelay")
    def no_connect_delay(self) -> Optional[str]:
        """
        The amount of time a VM will stay running before it is shutdown if no connection is made and this behavior is enabled. This value must be formatted as an ISO 8601 string.

        > **NOTE:** The `shutdownWhenNotConnected` is `Disabled` when `no_connect_delay` isn't specified.
        """
        return pulumi.get(self, "no_connect_delay")

    @property
    @pulumi.getter(name="shutdownOnIdle")
    def shutdown_on_idle(self) -> Optional[str]:
        """
        A VM will get shutdown when it has idled for a period of time. Possible values are `LowUsage` and `UserAbsence`.

        > **NOTE:** This property is `None` when it isn't specified. No need to set `idle_delay` when `shutdown_on_idle` isn't specified.
        """
        return pulumi.get(self, "shutdown_on_idle")


@pulumi.output_type
class LabConnectionSetting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientRdpAccess":
            suggest = "client_rdp_access"
        elif key == "clientSshAccess":
            suggest = "client_ssh_access"

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

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

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

    def __init__(__self__, *,
                 client_rdp_access: Optional[str] = None,
                 client_ssh_access: Optional[str] = None):
        """
        :param str client_rdp_access: The enabled access level for Client Access over RDP. Possible value is `Public`.
               
               > **NOTE:** This property is `None` when it isn't specified.
        :param str client_ssh_access: The enabled access level for Client Access over SSH. Possible value is `Public`.
               
               > **NOTE:** This property is `None` when it isn't specified.
        """
        if client_rdp_access is not None:
            pulumi.set(__self__, "client_rdp_access", client_rdp_access)
        if client_ssh_access is not None:
            pulumi.set(__self__, "client_ssh_access", client_ssh_access)

    @property
    @pulumi.getter(name="clientRdpAccess")
    def client_rdp_access(self) -> Optional[str]:
        """
        The enabled access level for Client Access over RDP. Possible value is `Public`.

        > **NOTE:** This property is `None` when it isn't specified.
        """
        return pulumi.get(self, "client_rdp_access")

    @property
    @pulumi.getter(name="clientSshAccess")
    def client_ssh_access(self) -> Optional[str]:
        """
        The enabled access level for Client Access over SSH. Possible value is `Public`.

        > **NOTE:** This property is `None` when it isn't specified.
        """
        return pulumi.get(self, "client_ssh_access")


@pulumi.output_type
class LabNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loadBalancerId":
            suggest = "load_balancer_id"
        elif key == "publicIpId":
            suggest = "public_ip_id"
        elif key == "subnetId":
            suggest = "subnet_id"

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

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

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

    def __init__(__self__, *,
                 load_balancer_id: Optional[str] = None,
                 public_ip_id: Optional[str] = None,
                 subnet_id: Optional[str] = None):
        """
        :param str load_balancer_id: The resource ID of the Load Balancer for the network profile of the Lab Service Lab.
        :param str public_ip_id: The resource ID of the Public IP for the network profile of the Lab Service Lab.
        :param str subnet_id: The resource ID of the Subnet for the network profile of the Lab Service Lab.
        """
        if load_balancer_id is not None:
            pulumi.set(__self__, "load_balancer_id", load_balancer_id)
        if public_ip_id is not None:
            pulumi.set(__self__, "public_ip_id", public_ip_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="loadBalancerId")
    def load_balancer_id(self) -> Optional[str]:
        """
        The resource ID of the Load Balancer for the network profile of the Lab Service Lab.
        """
        return pulumi.get(self, "load_balancer_id")

    @property
    @pulumi.getter(name="publicIpId")
    def public_ip_id(self) -> Optional[str]:
        """
        The resource ID of the Public IP for the network profile of the Lab Service Lab.
        """
        return pulumi.get(self, "public_ip_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The resource ID of the Subnet for the network profile of the Lab Service Lab.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class LabRoster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeDirectoryGroupId":
            suggest = "active_directory_group_id"
        elif key == "lmsInstance":
            suggest = "lms_instance"
        elif key == "ltiClientId":
            suggest = "lti_client_id"
        elif key == "ltiContextId":
            suggest = "lti_context_id"
        elif key == "ltiRosterEndpoint":
            suggest = "lti_roster_endpoint"

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

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

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

    def __init__(__self__, *,
                 active_directory_group_id: Optional[str] = None,
                 lms_instance: Optional[str] = None,
                 lti_client_id: Optional[str] = None,
                 lti_context_id: Optional[str] = None,
                 lti_roster_endpoint: Optional[str] = None):
        """
        :param str active_directory_group_id: The AAD group ID which this Lab Service Lab roster is populated from.
        :param str lms_instance: The base URI identifying the lms instance.
        :param str lti_client_id: The unique id of the Azure Lab Service tool in the lms.
        :param str lti_context_id: The unique context identifier for the Lab Service Lab in the lms.
        :param str lti_roster_endpoint: The URI of the names and roles service endpoint on the lms for the class attached to this Lab Service Lab.
        """
        if active_directory_group_id is not None:
            pulumi.set(__self__, "active_directory_group_id", active_directory_group_id)
        if lms_instance is not None:
            pulumi.set(__self__, "lms_instance", lms_instance)
        if lti_client_id is not None:
            pulumi.set(__self__, "lti_client_id", lti_client_id)
        if lti_context_id is not None:
            pulumi.set(__self__, "lti_context_id", lti_context_id)
        if lti_roster_endpoint is not None:
            pulumi.set(__self__, "lti_roster_endpoint", lti_roster_endpoint)

    @property
    @pulumi.getter(name="activeDirectoryGroupId")
    def active_directory_group_id(self) -> Optional[str]:
        """
        The AAD group ID which this Lab Service Lab roster is populated from.
        """
        return pulumi.get(self, "active_directory_group_id")

    @property
    @pulumi.getter(name="lmsInstance")
    def lms_instance(self) -> Optional[str]:
        """
        The base URI identifying the lms instance.
        """
        return pulumi.get(self, "lms_instance")

    @property
    @pulumi.getter(name="ltiClientId")
    def lti_client_id(self) -> Optional[str]:
        """
        The unique id of the Azure Lab Service tool in the lms.
        """
        return pulumi.get(self, "lti_client_id")

    @property
    @pulumi.getter(name="ltiContextId")
    def lti_context_id(self) -> Optional[str]:
        """
        The unique context identifier for the Lab Service Lab in the lms.
        """
        return pulumi.get(self, "lti_context_id")

    @property
    @pulumi.getter(name="ltiRosterEndpoint")
    def lti_roster_endpoint(self) -> Optional[str]:
        """
        The URI of the names and roles service endpoint on the lms for the class attached to this Lab Service Lab.
        """
        return pulumi.get(self, "lti_roster_endpoint")


@pulumi.output_type
class LabSecurity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "openAccessEnabled":
            suggest = "open_access_enabled"
        elif key == "registrationCode":
            suggest = "registration_code"

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

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

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

    def __init__(__self__, *,
                 open_access_enabled: bool,
                 registration_code: Optional[str] = None):
        """
        :param bool open_access_enabled: Is open access enabled to allow any user or only specified users to register to a Lab Service Lab?
        :param str registration_code: The registration code for the Lab Service Lab.
        """
        pulumi.set(__self__, "open_access_enabled", open_access_enabled)
        if registration_code is not None:
            pulumi.set(__self__, "registration_code", registration_code)

    @property
    @pulumi.getter(name="openAccessEnabled")
    def open_access_enabled(self) -> bool:
        """
        Is open access enabled to allow any user or only specified users to register to a Lab Service Lab?
        """
        return pulumi.get(self, "open_access_enabled")

    @property
    @pulumi.getter(name="registrationCode")
    def registration_code(self) -> Optional[str]:
        """
        The registration code for the Lab Service Lab.
        """
        return pulumi.get(self, "registration_code")


@pulumi.output_type
class LabVirtualMachine(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adminUser":
            suggest = "admin_user"
        elif key == "imageReference":
            suggest = "image_reference"
        elif key == "additionalCapabilityGpuDriversInstalled":
            suggest = "additional_capability_gpu_drivers_installed"
        elif key == "createOption":
            suggest = "create_option"
        elif key == "nonAdminUser":
            suggest = "non_admin_user"
        elif key == "sharedPasswordEnabled":
            suggest = "shared_password_enabled"
        elif key == "usageQuota":
            suggest = "usage_quota"

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

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

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

    def __init__(__self__, *,
                 admin_user: 'outputs.LabVirtualMachineAdminUser',
                 image_reference: 'outputs.LabVirtualMachineImageReference',
                 sku: 'outputs.LabVirtualMachineSku',
                 additional_capability_gpu_drivers_installed: Optional[bool] = None,
                 create_option: Optional[str] = None,
                 non_admin_user: Optional['outputs.LabVirtualMachineNonAdminUser'] = None,
                 shared_password_enabled: Optional[bool] = None,
                 usage_quota: Optional[str] = None):
        """
        :param 'LabVirtualMachineAdminUserArgs' admin_user: An `admin_user` block as defined below.
        :param 'LabVirtualMachineImageReferenceArgs' image_reference: An `image_reference` block as defined below.
        :param 'LabVirtualMachineSkuArgs' sku: A `sku` block as defined below.
        :param bool additional_capability_gpu_drivers_installed: Is flagged to pre-install dedicated GPU drivers? Defaults to `false`. Changing this forces a new resource to be created.
        :param str create_option: The create option to indicate what Lab Service Lab VMs are created from. Possible values are `Image` and `TemplateVM`. Defaults to `Image`. Changing this forces a new resource to be created.
        :param 'LabVirtualMachineNonAdminUserArgs' non_admin_user: A `non_admin_user` block as defined below.
        :param bool shared_password_enabled: Is the shared password enabled with the same password for all user VMs? Defaults to `false`. Changing this forces a new resource to be created.
        :param str usage_quota: The initial quota allocated to each Lab Service Lab user. Defaults to `PT0S`. This value must be formatted as an ISO 8601 string.
        """
        pulumi.set(__self__, "admin_user", admin_user)
        pulumi.set(__self__, "image_reference", image_reference)
        pulumi.set(__self__, "sku", sku)
        if additional_capability_gpu_drivers_installed is not None:
            pulumi.set(__self__, "additional_capability_gpu_drivers_installed", additional_capability_gpu_drivers_installed)
        if create_option is not None:
            pulumi.set(__self__, "create_option", create_option)
        if non_admin_user is not None:
            pulumi.set(__self__, "non_admin_user", non_admin_user)
        if shared_password_enabled is not None:
            pulumi.set(__self__, "shared_password_enabled", shared_password_enabled)
        if usage_quota is not None:
            pulumi.set(__self__, "usage_quota", usage_quota)

    @property
    @pulumi.getter(name="adminUser")
    def admin_user(self) -> 'outputs.LabVirtualMachineAdminUser':
        """
        An `admin_user` block as defined below.
        """
        return pulumi.get(self, "admin_user")

    @property
    @pulumi.getter(name="imageReference")
    def image_reference(self) -> 'outputs.LabVirtualMachineImageReference':
        """
        An `image_reference` block as defined below.
        """
        return pulumi.get(self, "image_reference")

    @property
    @pulumi.getter
    def sku(self) -> 'outputs.LabVirtualMachineSku':
        """
        A `sku` block as defined below.
        """
        return pulumi.get(self, "sku")

    @property
    @pulumi.getter(name="additionalCapabilityGpuDriversInstalled")
    def additional_capability_gpu_drivers_installed(self) -> Optional[bool]:
        """
        Is flagged to pre-install dedicated GPU drivers? Defaults to `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "additional_capability_gpu_drivers_installed")

    @property
    @pulumi.getter(name="createOption")
    def create_option(self) -> Optional[str]:
        """
        The create option to indicate what Lab Service Lab VMs are created from. Possible values are `Image` and `TemplateVM`. Defaults to `Image`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "create_option")

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

    @property
    @pulumi.getter(name="sharedPasswordEnabled")
    def shared_password_enabled(self) -> Optional[bool]:
        """
        Is the shared password enabled with the same password for all user VMs? Defaults to `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "shared_password_enabled")

    @property
    @pulumi.getter(name="usageQuota")
    def usage_quota(self) -> Optional[str]:
        """
        The initial quota allocated to each Lab Service Lab user. Defaults to `PT0S`. This value must be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "usage_quota")


@pulumi.output_type
class LabVirtualMachineAdminUser(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password for the Lab user. Changing this forces a new resource to be created.
        :param str username: The username to use when signing in to Lab Service Lab VMs. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username to use when signing in to Lab Service Lab VMs. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class LabVirtualMachineImageReference(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: The resource ID of the image. Changing this forces a new resource to be created.
        :param str offer: The image offer if applicable. Changing this forces a new resource to be created.
        :param str publisher: The image publisher. Changing this forces a new resource to be created.
        :param str sku: The image SKU. Changing this forces a new resource to be created.
        :param str version: The image version specified on creation. 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]:
        """
        The resource ID of the image. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def offer(self) -> Optional[str]:
        """
        The image offer if applicable. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "offer")

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

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

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        The image version specified on creation. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class LabVirtualMachineNonAdminUser(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password for the user.
        :param str username: The username to use when signing in to Lab Service Lab VMs.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username to use when signing in to Lab Service Lab VMs.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class LabVirtualMachineSku(dict):
    def __init__(__self__, *,
                 capacity: int,
                 name: str):
        """
        :param int capacity: The capacity for the SKU. Possible values are between `0` and `400`.
               
               > **NOTE:** Once `active_directory_group_id` is enabled, `capacity` wouldn't take effect, and it would be automatically set to the number of members in AAD Group by service API. So it has to use `ignore_changes` to avoid the difference of tf plan.
        :param str name: The name of the SKU. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "capacity", capacity)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def capacity(self) -> int:
        """
        The capacity for the SKU. Possible values are between `0` and `400`.

        > **NOTE:** Once `active_directory_group_id` is enabled, `capacity` wouldn't take effect, and it would be automatically set to the number of members in AAD Group by service API. So it has to use `ignore_changes` to avoid the difference of tf plan.
        """
        return pulumi.get(self, "capacity")

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


@pulumi.output_type
class ScheduleRecurrence(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "expirationDate":
            suggest = "expiration_date"
        elif key == "weekDays":
            suggest = "week_days"

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

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

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

    def __init__(__self__, *,
                 expiration_date: str,
                 frequency: str,
                 interval: Optional[int] = None,
                 week_days: Optional[Sequence[str]] = None):
        """
        :param str expiration_date: When the recurrence will expire in RFC-3339 format.
        :param str frequency: The frequency of the recurrence. Possible values are `Daily` and `Weekly`.
        :param int interval: The interval to invoke the schedule on. Possible values are between `1` and `365`.
        :param Sequence[str] week_days: The interval to invoke the schedule on. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
        """
        pulumi.set(__self__, "expiration_date", expiration_date)
        pulumi.set(__self__, "frequency", frequency)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if week_days is not None:
            pulumi.set(__self__, "week_days", week_days)

    @property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> str:
        """
        When the recurrence will expire in RFC-3339 format.
        """
        return pulumi.get(self, "expiration_date")

    @property
    @pulumi.getter
    def frequency(self) -> str:
        """
        The frequency of the recurrence. Possible values are `Daily` and `Weekly`.
        """
        return pulumi.get(self, "frequency")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        The interval to invoke the schedule on. Possible values are between `1` and `365`.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter(name="weekDays")
    def week_days(self) -> Optional[Sequence[str]]:
        """
        The interval to invoke the schedule on. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
        """
        return pulumi.get(self, "week_days")


@pulumi.output_type
class ServicePlanDefaultAutoShutdown(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disconnectDelay":
            suggest = "disconnect_delay"
        elif key == "idleDelay":
            suggest = "idle_delay"
        elif key == "noConnectDelay":
            suggest = "no_connect_delay"
        elif key == "shutdownOnIdle":
            suggest = "shutdown_on_idle"

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

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

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

    def __init__(__self__, *,
                 disconnect_delay: Optional[str] = None,
                 idle_delay: Optional[str] = None,
                 no_connect_delay: Optional[str] = None,
                 shutdown_on_idle: Optional[str] = None):
        """
        :param str disconnect_delay: The amount of time a VM will stay running after a user disconnects if this behavior is enabled. This value must be formatted as an ISO 8601 string.
        :param str idle_delay: The amount of time a VM will idle before it is shutdown if this behavior is enabled. This value must be formatted as an ISO 8601 string.
        :param str no_connect_delay: The amount of time a VM will stay running before it is shutdown if no connection is made and this behavior is enabled. This value must be formatted as an ISO 8601 string.
        :param str shutdown_on_idle: Will a VM get shutdown when it has idled for a period of time? Possible values are `LowUsage` and `UserAbsence`.
               
               > **NOTE:** This property is `None` when it isn't specified. No need to set `idle_delay` when `shutdown_on_idle` isn't specified.
        """
        if disconnect_delay is not None:
            pulumi.set(__self__, "disconnect_delay", disconnect_delay)
        if idle_delay is not None:
            pulumi.set(__self__, "idle_delay", idle_delay)
        if no_connect_delay is not None:
            pulumi.set(__self__, "no_connect_delay", no_connect_delay)
        if shutdown_on_idle is not None:
            pulumi.set(__self__, "shutdown_on_idle", shutdown_on_idle)

    @property
    @pulumi.getter(name="disconnectDelay")
    def disconnect_delay(self) -> Optional[str]:
        """
        The amount of time a VM will stay running after a user disconnects if this behavior is enabled. This value must be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "disconnect_delay")

    @property
    @pulumi.getter(name="idleDelay")
    def idle_delay(self) -> Optional[str]:
        """
        The amount of time a VM will idle before it is shutdown if this behavior is enabled. This value must be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "idle_delay")

    @property
    @pulumi.getter(name="noConnectDelay")
    def no_connect_delay(self) -> Optional[str]:
        """
        The amount of time a VM will stay running before it is shutdown if no connection is made and this behavior is enabled. This value must be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "no_connect_delay")

    @property
    @pulumi.getter(name="shutdownOnIdle")
    def shutdown_on_idle(self) -> Optional[str]:
        """
        Will a VM get shutdown when it has idled for a period of time? Possible values are `LowUsage` and `UserAbsence`.

        > **NOTE:** This property is `None` when it isn't specified. No need to set `idle_delay` when `shutdown_on_idle` isn't specified.
        """
        return pulumi.get(self, "shutdown_on_idle")


@pulumi.output_type
class ServicePlanDefaultConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientRdpAccess":
            suggest = "client_rdp_access"
        elif key == "clientSshAccess":
            suggest = "client_ssh_access"
        elif key == "webRdpAccess":
            suggest = "web_rdp_access"
        elif key == "webSshAccess":
            suggest = "web_ssh_access"

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

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

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

    def __init__(__self__, *,
                 client_rdp_access: Optional[str] = None,
                 client_ssh_access: Optional[str] = None,
                 web_rdp_access: Optional[str] = None,
                 web_ssh_access: Optional[str] = None):
        """
        :param str client_rdp_access: The enabled access level for Client Access over RDP. Possible values are `Private` and `Public`.
               
               > **NOTE:** This property is `None` when it isn't specified.
        :param str client_ssh_access: The enabled access level for Client Access over SSH. Possible values are `Private` and `Public`.
               
               > **NOTE:** This property is `None` when it isn't specified.
        :param str web_rdp_access: The enabled access level for Web Access over RDP. Possible values are `Private` and `Public`.
               
               > **NOTE:** This property is `None` when it isn't specified.
        :param str web_ssh_access: The enabled access level for Web Access over SSH. Possible values are `Private` and `Public`.
               
               > **NOTE:** This property is `None` when it isn't specified.
        """
        if client_rdp_access is not None:
            pulumi.set(__self__, "client_rdp_access", client_rdp_access)
        if client_ssh_access is not None:
            pulumi.set(__self__, "client_ssh_access", client_ssh_access)
        if web_rdp_access is not None:
            pulumi.set(__self__, "web_rdp_access", web_rdp_access)
        if web_ssh_access is not None:
            pulumi.set(__self__, "web_ssh_access", web_ssh_access)

    @property
    @pulumi.getter(name="clientRdpAccess")
    def client_rdp_access(self) -> Optional[str]:
        """
        The enabled access level for Client Access over RDP. Possible values are `Private` and `Public`.

        > **NOTE:** This property is `None` when it isn't specified.
        """
        return pulumi.get(self, "client_rdp_access")

    @property
    @pulumi.getter(name="clientSshAccess")
    def client_ssh_access(self) -> Optional[str]:
        """
        The enabled access level for Client Access over SSH. Possible values are `Private` and `Public`.

        > **NOTE:** This property is `None` when it isn't specified.
        """
        return pulumi.get(self, "client_ssh_access")

    @property
    @pulumi.getter(name="webRdpAccess")
    def web_rdp_access(self) -> Optional[str]:
        """
        The enabled access level for Web Access over RDP. Possible values are `Private` and `Public`.

        > **NOTE:** This property is `None` when it isn't specified.
        """
        return pulumi.get(self, "web_rdp_access")

    @property
    @pulumi.getter(name="webSshAccess")
    def web_ssh_access(self) -> Optional[str]:
        """
        The enabled access level for Web Access over SSH. Possible values are `Private` and `Public`.

        > **NOTE:** This property is `None` when it isn't specified.
        """
        return pulumi.get(self, "web_ssh_access")


@pulumi.output_type
class ServicePlanSupport(dict):
    def __init__(__self__, *,
                 email: Optional[str] = None,
                 instructions: Optional[str] = None,
                 phone: Optional[str] = None,
                 url: Optional[str] = None):
        """
        :param str email: The email address for the support contact.
        :param str instructions: The instructions for users of the Lab Service Plan.
        :param str phone: The phone number for the support contact.
        :param str url: The web address for users of the Lab Service Plan.
        """
        if email is not None:
            pulumi.set(__self__, "email", email)
        if instructions is not None:
            pulumi.set(__self__, "instructions", instructions)
        if phone is not None:
            pulumi.set(__self__, "phone", phone)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def email(self) -> Optional[str]:
        """
        The email address for the support contact.
        """
        return pulumi.get(self, "email")

    @property
    @pulumi.getter
    def instructions(self) -> Optional[str]:
        """
        The instructions for users of the Lab Service Plan.
        """
        return pulumi.get(self, "instructions")

    @property
    @pulumi.getter
    def phone(self) -> Optional[str]:
        """
        The phone number for the support contact.
        """
        return pulumi.get(self, "phone")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        The web address for users of the Lab Service Plan.
        """
        return pulumi.get(self, "url")


