# 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 sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'AccountEncryption',
    'AccountIdentity',
    'AccountPrivateEndpointConnection',
    'ConnectionTypeField',
    'ModuleModuleLink',
    'ModuleModuleLinkHash',
    'Powershell72ModuleModuleLink',
    'Powershell72ModuleModuleLinkHash',
    'RunBookDraft',
    'RunBookDraftContentLink',
    'RunBookDraftContentLinkHash',
    'RunBookDraftParameter',
    'RunBookJobSchedule',
    'RunBookPublishContentLink',
    'RunBookPublishContentLinkHash',
    'ScheduleMonthlyOccurrence',
    'SoftwareUpdateConfigurationLinux',
    'SoftwareUpdateConfigurationPostTask',
    'SoftwareUpdateConfigurationPreTask',
    'SoftwareUpdateConfigurationSchedule',
    'SoftwareUpdateConfigurationScheduleMonthlyOccurrence',
    'SoftwareUpdateConfigurationTarget',
    'SoftwareUpdateConfigurationTargetAzureQuery',
    'SoftwareUpdateConfigurationTargetAzureQueryTag',
    'SoftwareUpdateConfigurationTargetNonAzureQuery',
    'SoftwareUpdateConfigurationWindows',
    'SourceControlSecurity',
    'GetAccountIdentityResult',
    'GetAccountPrivateEndpointConnectionResult',
    'GetVariablesBoolResult',
    'GetVariablesDatetimeResult',
    'GetVariablesEncryptedResult',
    'GetVariablesIntResult',
    'GetVariablesNullResult',
    'GetVariablesObjectResult',
    'GetVariablesStringResult',
]

@pulumi.output_type
class AccountEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyVaultKeyId":
            suggest = "key_vault_key_id"
        elif key == "keySource":
            suggest = "key_source"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

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

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

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

    def __init__(__self__, *,
                 key_vault_key_id: str,
                 key_source: Optional[str] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param str key_vault_key_id: The ID of the Key Vault Key which should be used to Encrypt the data in this Automation Account.
        :param str user_assigned_identity_id: The User Assigned Managed Identity ID to be used for accessing the Customer Managed Key for encryption.
        """
        pulumi.set(__self__, "key_vault_key_id", key_vault_key_id)
        if key_source is not None:
            pulumi.set(__self__, "key_source", key_source)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="keyVaultKeyId")
    def key_vault_key_id(self) -> str:
        """
        The ID of the Key Vault Key which should be used to Encrypt the data in this Automation Account.
        """
        return pulumi.get(self, "key_vault_key_id")

    @property
    @pulumi.getter(name="keySource")
    @_utilities.deprecated("""This field is now ignored and will be removed in the next major version of the Azure Provider, the `encryption` block can be omitted to disable encryption""")
    def key_source(self) -> Optional[str]:
        return pulumi.get(self, "key_source")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[str]:
        """
        The User Assigned Managed Identity ID to be used for accessing the Customer Managed Key for encryption.
        """
        return pulumi.get(self, "user_assigned_identity_id")


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

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

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

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

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: The type of identity used for this Automation Account. Possible values are `SystemAssigned`, `UserAssigned` and `SystemAssigned, UserAssigned`.
        :param Sequence[str] identity_ids: The ID of the User Assigned Identity which should be assigned to this Automation Account.
               
               > **Note:** `identity_ids` is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        :param str principal_id: The Principal ID associated with this Managed Service Identity.
        :param str tenant_id: The Tenant ID associated with this Managed Service Identity.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of identity used for this Automation Account. Possible values are `SystemAssigned`, `UserAssigned` and `SystemAssigned, UserAssigned`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        The ID of the User Assigned Identity which should be assigned to this Automation Account.

        > **Note:** `identity_ids` is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        """
        return pulumi.get(self, "identity_ids")

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

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


@pulumi.output_type
class AccountPrivateEndpointConnection(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 name: Optional[str] = None):
        """
        :param str id: The ID of the Automation Account.
        :param str name: Specifies the name of the Automation Account. Changing this forces a new resource to be created.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        The ID of the Automation Account.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class ConnectionTypeField(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEncrypted":
            suggest = "is_encrypted"
        elif key == "isOptional":
            suggest = "is_optional"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 type: str,
                 is_encrypted: Optional[bool] = None,
                 is_optional: Optional[bool] = None):
        """
        :param str name: The name which should be used for this connection field definition.
        :param str type: The type of the connection field definition.
        :param bool is_encrypted: Whether to set the isEncrypted flag of the connection field definition.
        :param bool is_optional: Whether to set the isOptional flag of the connection field definition.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if is_encrypted is not None:
            pulumi.set(__self__, "is_encrypted", is_encrypted)
        if is_optional is not None:
            pulumi.set(__self__, "is_optional", is_optional)

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

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the connection field definition.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="isEncrypted")
    def is_encrypted(self) -> Optional[bool]:
        """
        Whether to set the isEncrypted flag of the connection field definition.
        """
        return pulumi.get(self, "is_encrypted")

    @property
    @pulumi.getter(name="isOptional")
    def is_optional(self) -> Optional[bool]:
        """
        Whether to set the isOptional flag of the connection field definition.
        """
        return pulumi.get(self, "is_optional")


@pulumi.output_type
class ModuleModuleLink(dict):
    def __init__(__self__, *,
                 uri: str,
                 hash: Optional['outputs.ModuleModuleLinkHash'] = None):
        """
        :param str uri: The URI of the module content (zip or nupkg).
        :param 'ModuleModuleLinkHashArgs' hash: A `hash` block as defined below.
        """
        pulumi.set(__self__, "uri", uri)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the module content (zip or nupkg).
        """
        return pulumi.get(self, "uri")

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


@pulumi.output_type
class ModuleModuleLinkHash(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 value: str):
        """
        :param str algorithm: Specifies the algorithm used for the hash content.
        :param str value: The hash value of the content.
        """
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def algorithm(self) -> str:
        """
        Specifies the algorithm used for the hash content.
        """
        return pulumi.get(self, "algorithm")

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


@pulumi.output_type
class Powershell72ModuleModuleLink(dict):
    def __init__(__self__, *,
                 uri: str,
                 hash: Optional['outputs.Powershell72ModuleModuleLinkHash'] = None):
        """
        :param str uri: The URI of the module content (zip or nupkg).
        :param 'Powershell72ModuleModuleLinkHashArgs' hash: A `hash` block as defined below.
        """
        pulumi.set(__self__, "uri", uri)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the module content (zip or nupkg).
        """
        return pulumi.get(self, "uri")

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


@pulumi.output_type
class Powershell72ModuleModuleLinkHash(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 value: str):
        """
        :param str algorithm: Specifies the algorithm used for the hash content.
        :param str value: The hash value of the content.
        """
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def algorithm(self) -> str:
        """
        Specifies the algorithm used for the hash content.
        """
        return pulumi.get(self, "algorithm")

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


@pulumi.output_type
class RunBookDraft(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentLink":
            suggest = "content_link"
        elif key == "creationTime":
            suggest = "creation_time"
        elif key == "editModeEnabled":
            suggest = "edit_mode_enabled"
        elif key == "lastModifiedTime":
            suggest = "last_modified_time"
        elif key == "outputTypes":
            suggest = "output_types"

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

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

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

    def __init__(__self__, *,
                 content_link: Optional['outputs.RunBookDraftContentLink'] = None,
                 creation_time: Optional[str] = None,
                 edit_mode_enabled: Optional[bool] = None,
                 last_modified_time: Optional[str] = None,
                 output_types: Optional[Sequence[str]] = None,
                 parameters: Optional[Sequence['outputs.RunBookDraftParameter']] = None):
        """
        :param 'RunBookDraftContentLinkArgs' content_link: A `publish_content_link` block as defined above.
        :param bool edit_mode_enabled: Whether the draft in edit mode.
        :param Sequence[str] output_types: Specifies the output types of the runbook.
        :param Sequence['RunBookDraftParameterArgs'] parameters: A list of `parameters` block as defined below.
        """
        if content_link is not None:
            pulumi.set(__self__, "content_link", content_link)
        if creation_time is not None:
            pulumi.set(__self__, "creation_time", creation_time)
        if edit_mode_enabled is not None:
            pulumi.set(__self__, "edit_mode_enabled", edit_mode_enabled)
        if last_modified_time is not None:
            pulumi.set(__self__, "last_modified_time", last_modified_time)
        if output_types is not None:
            pulumi.set(__self__, "output_types", output_types)
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)

    @property
    @pulumi.getter(name="contentLink")
    def content_link(self) -> Optional['outputs.RunBookDraftContentLink']:
        """
        A `publish_content_link` block as defined above.
        """
        return pulumi.get(self, "content_link")

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

    @property
    @pulumi.getter(name="editModeEnabled")
    def edit_mode_enabled(self) -> Optional[bool]:
        """
        Whether the draft in edit mode.
        """
        return pulumi.get(self, "edit_mode_enabled")

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

    @property
    @pulumi.getter(name="outputTypes")
    def output_types(self) -> Optional[Sequence[str]]:
        """
        Specifies the output types of the runbook.
        """
        return pulumi.get(self, "output_types")

    @property
    @pulumi.getter
    def parameters(self) -> Optional[Sequence['outputs.RunBookDraftParameter']]:
        """
        A list of `parameters` block as defined below.
        """
        return pulumi.get(self, "parameters")


@pulumi.output_type
class RunBookDraftContentLink(dict):
    def __init__(__self__, *,
                 uri: str,
                 hash: Optional['outputs.RunBookDraftContentLinkHash'] = None,
                 version: Optional[str] = None):
        """
        :param str uri: The URI of the runbook content.
        :param 'RunBookDraftContentLinkHashArgs' hash: A `hash` block as defined below.
        :param str version: Specifies the version of the content
        """
        pulumi.set(__self__, "uri", uri)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the runbook content.
        """
        return pulumi.get(self, "uri")

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

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Specifies the version of the content
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class RunBookDraftContentLinkHash(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 value: str):
        """
        :param str algorithm: Specifies the hash algorithm used to hash the content.
        :param str value: Specifies the expected hash value of the content.
        """
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def algorithm(self) -> str:
        """
        Specifies the hash algorithm used to hash the content.
        """
        return pulumi.get(self, "algorithm")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Specifies the expected hash value of the content.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RunBookDraftParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 key: str,
                 type: str,
                 default_value: Optional[str] = None,
                 mandatory: Optional[bool] = None,
                 position: Optional[int] = None):
        """
        :param str key: The name of the parameter.
        :param str type: Specifies the type of this parameter.
        :param str default_value: Specifies the default value of the parameter.
        :param bool mandatory: Whether this parameter is mandatory.
        :param int position: Specifies the position of the parameter.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if mandatory is not None:
            pulumi.set(__self__, "mandatory", mandatory)
        if position is not None:
            pulumi.set(__self__, "position", position)

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

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of this parameter.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[str]:
        """
        Specifies the default value of the parameter.
        """
        return pulumi.get(self, "default_value")

    @property
    @pulumi.getter
    def mandatory(self) -> Optional[bool]:
        """
        Whether this parameter is mandatory.
        """
        return pulumi.get(self, "mandatory")

    @property
    @pulumi.getter
    def position(self) -> Optional[int]:
        """
        Specifies the position of the parameter.
        """
        return pulumi.get(self, "position")


@pulumi.output_type
class RunBookJobSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scheduleName":
            suggest = "schedule_name"
        elif key == "jobScheduleId":
            suggest = "job_schedule_id"
        elif key == "runOn":
            suggest = "run_on"

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

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

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

    def __init__(__self__, *,
                 schedule_name: str,
                 job_schedule_id: Optional[str] = None,
                 parameters: Optional[Mapping[str, str]] = None,
                 run_on: Optional[str] = None):
        """
        :param str schedule_name: The name of the Schedule.
        :param str job_schedule_id: The UUID of automation runbook job schedule ID.
        :param Mapping[str, str] parameters: A map of key/value pairs corresponding to the arguments that can be passed to the Runbook.
               
               > **NOTE:** The parameter keys/names must strictly be in lowercase, even if this is not the case in the runbook. This is due to a limitation in Azure Automation where the parameter names are normalized. The values specified don't have this limitation.
        :param str run_on: Name of a Hybrid Worker Group the Runbook will be executed on.
        """
        pulumi.set(__self__, "schedule_name", schedule_name)
        if job_schedule_id is not None:
            pulumi.set(__self__, "job_schedule_id", job_schedule_id)
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)
        if run_on is not None:
            pulumi.set(__self__, "run_on", run_on)

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

    @property
    @pulumi.getter(name="jobScheduleId")
    def job_schedule_id(self) -> Optional[str]:
        """
        The UUID of automation runbook job schedule ID.
        """
        return pulumi.get(self, "job_schedule_id")

    @property
    @pulumi.getter
    def parameters(self) -> Optional[Mapping[str, str]]:
        """
        A map of key/value pairs corresponding to the arguments that can be passed to the Runbook.

        > **NOTE:** The parameter keys/names must strictly be in lowercase, even if this is not the case in the runbook. This is due to a limitation in Azure Automation where the parameter names are normalized. The values specified don't have this limitation.
        """
        return pulumi.get(self, "parameters")

    @property
    @pulumi.getter(name="runOn")
    def run_on(self) -> Optional[str]:
        """
        Name of a Hybrid Worker Group the Runbook will be executed on.
        """
        return pulumi.get(self, "run_on")


@pulumi.output_type
class RunBookPublishContentLink(dict):
    def __init__(__self__, *,
                 uri: str,
                 hash: Optional['outputs.RunBookPublishContentLinkHash'] = None,
                 version: Optional[str] = None):
        """
        :param str uri: The URI of the runbook content.
        :param 'RunBookPublishContentLinkHashArgs' hash: A `hash` block as defined below.
        :param str version: Specifies the version of the content
        """
        pulumi.set(__self__, "uri", uri)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the runbook content.
        """
        return pulumi.get(self, "uri")

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

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Specifies the version of the content
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class RunBookPublishContentLinkHash(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 value: str):
        """
        :param str algorithm: Specifies the hash algorithm used to hash the content.
        :param str value: Specifies the expected hash value of the content.
        """
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def algorithm(self) -> str:
        """
        Specifies the hash algorithm used to hash the content.
        """
        return pulumi.get(self, "algorithm")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Specifies the expected hash value of the content.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ScheduleMonthlyOccurrence(dict):
    def __init__(__self__, *,
                 day: str,
                 occurrence: int):
        """
        :param str day: Day of the occurrence. Must be one of `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, `Sunday`.
        :param int occurrence: Occurrence of the week within the month. Must be between `1` and `5`. `-1` for last week within the month.
        """
        pulumi.set(__self__, "day", day)
        pulumi.set(__self__, "occurrence", occurrence)

    @property
    @pulumi.getter
    def day(self) -> str:
        """
        Day of the occurrence. Must be one of `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, `Sunday`.
        """
        return pulumi.get(self, "day")

    @property
    @pulumi.getter
    def occurrence(self) -> int:
        """
        Occurrence of the week within the month. Must be between `1` and `5`. `-1` for last week within the month.
        """
        return pulumi.get(self, "occurrence")


@pulumi.output_type
class SoftwareUpdateConfigurationLinux(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "classificationsIncludeds":
            suggest = "classifications_includeds"
        elif key == "excludedPackages":
            suggest = "excluded_packages"
        elif key == "includedPackages":
            suggest = "included_packages"

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

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

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

    def __init__(__self__, *,
                 classifications_includeds: Sequence[str],
                 excluded_packages: Optional[Sequence[str]] = None,
                 included_packages: Optional[Sequence[str]] = None,
                 reboot: Optional[str] = None):
        """
        :param Sequence[str] classifications_includeds: Specifies the list of update classifications included in the Software Update Configuration. Possible values are `Unclassified`, `Critical`, `Security` and `Other`.
               
               > **NOTE:** The `classifications_included` property will become `Required` in version 4.0 of the Provider.
        :param Sequence[str] excluded_packages: Specifies a list of packages to excluded from the Software Update Configuration.
        :param Sequence[str] included_packages: Specifies a list of packages to included from the Software Update Configuration.
        :param str reboot: Specifies the reboot settings after software update, possible values are `IfRequired`, `Never`, `RebootOnly` and `Always`. Defaults to `IfRequired`.
        """
        pulumi.set(__self__, "classifications_includeds", classifications_includeds)
        if excluded_packages is not None:
            pulumi.set(__self__, "excluded_packages", excluded_packages)
        if included_packages is not None:
            pulumi.set(__self__, "included_packages", included_packages)
        if reboot is not None:
            pulumi.set(__self__, "reboot", reboot)

    @property
    @pulumi.getter(name="classificationsIncludeds")
    def classifications_includeds(self) -> Sequence[str]:
        """
        Specifies the list of update classifications included in the Software Update Configuration. Possible values are `Unclassified`, `Critical`, `Security` and `Other`.

        > **NOTE:** The `classifications_included` property will become `Required` in version 4.0 of the Provider.
        """
        return pulumi.get(self, "classifications_includeds")

    @property
    @pulumi.getter(name="excludedPackages")
    def excluded_packages(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of packages to excluded from the Software Update Configuration.
        """
        return pulumi.get(self, "excluded_packages")

    @property
    @pulumi.getter(name="includedPackages")
    def included_packages(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of packages to included from the Software Update Configuration.
        """
        return pulumi.get(self, "included_packages")

    @property
    @pulumi.getter
    def reboot(self) -> Optional[str]:
        """
        Specifies the reboot settings after software update, possible values are `IfRequired`, `Never`, `RebootOnly` and `Always`. Defaults to `IfRequired`.
        """
        return pulumi.get(self, "reboot")


@pulumi.output_type
class SoftwareUpdateConfigurationPostTask(dict):
    def __init__(__self__, *,
                 parameters: Optional[Mapping[str, str]] = None,
                 source: Optional[str] = None):
        """
        :param Mapping[str, str] parameters: Specifies a map of parameters for the task.
        :param str source: The name of the runbook for the post task.
        """
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter
    def parameters(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of parameters for the task.
        """
        return pulumi.get(self, "parameters")

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


@pulumi.output_type
class SoftwareUpdateConfigurationPreTask(dict):
    def __init__(__self__, *,
                 parameters: Optional[Mapping[str, str]] = None,
                 source: Optional[str] = None):
        """
        :param Mapping[str, str] parameters: Specifies a map of parameters for the task.
        :param str source: The name of the runbook for the pre task.
        """
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter
    def parameters(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of parameters for the task.
        """
        return pulumi.get(self, "parameters")

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


@pulumi.output_type
class SoftwareUpdateConfigurationSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "advancedMonthDays":
            suggest = "advanced_month_days"
        elif key == "advancedWeekDays":
            suggest = "advanced_week_days"
        elif key == "creationTime":
            suggest = "creation_time"
        elif key == "expiryTime":
            suggest = "expiry_time"
        elif key == "expiryTimeOffsetMinutes":
            suggest = "expiry_time_offset_minutes"
        elif key == "isEnabled":
            suggest = "is_enabled"
        elif key == "lastModifiedTime":
            suggest = "last_modified_time"
        elif key == "monthlyOccurrence":
            suggest = "monthly_occurrence"
        elif key == "nextRun":
            suggest = "next_run"
        elif key == "nextRunOffsetMinutes":
            suggest = "next_run_offset_minutes"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "startTimeOffsetMinutes":
            suggest = "start_time_offset_minutes"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 frequency: str,
                 advanced_month_days: Optional[Sequence[int]] = None,
                 advanced_week_days: Optional[Sequence[str]] = None,
                 creation_time: Optional[str] = None,
                 description: Optional[str] = None,
                 expiry_time: Optional[str] = None,
                 expiry_time_offset_minutes: Optional[float] = None,
                 interval: Optional[int] = None,
                 is_enabled: Optional[bool] = None,
                 last_modified_time: Optional[str] = None,
                 monthly_occurrence: Optional['outputs.SoftwareUpdateConfigurationScheduleMonthlyOccurrence'] = None,
                 next_run: Optional[str] = None,
                 next_run_offset_minutes: Optional[float] = None,
                 start_time: Optional[str] = None,
                 start_time_offset_minutes: Optional[float] = None,
                 time_zone: Optional[str] = None):
        """
        :param str frequency: The frequency of the schedule. - can be either `OneTime`, `Day`, `Hour`, `Week`, or `Month`.
        :param Sequence[int] advanced_month_days: List of days of the month that the job should execute on. Must be between `1` and `31`. `-1` for last day of the month. Only valid when frequency is `Month`.
        :param Sequence[str] advanced_week_days: List of days of the week that the job should execute on. Only valid when frequency is `Week`. Possible values include `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, and `Sunday`.
        :param str description: A description for this Schedule.
        :param str expiry_time: The end time of the schedule.
        :param int interval: The number of `frequency`s between runs. Only valid when frequency is `Day`, `Hour`, `Week`, or `Month`.
        :param bool is_enabled: Whether the schedule is enabled. Defaults to `true`.
        :param 'SoftwareUpdateConfigurationScheduleMonthlyOccurrenceArgs' monthly_occurrence: List of `monthly_occurrence` blocks as defined below to specifies occurrences of days within a month. Only valid when frequency is `Month`. The `monthly_occurrence` block supports fields as defined below.
        :param str start_time: Start time of the schedule. Must be at least five minutes in the future. Defaults to seven minutes in the future from the time the resource is created.
        :param str time_zone: The timezone of the start time. Defaults to `Etc/UTC`. For possible values see: <https://docs.microsoft.com/en-us/rest/api/maps/timezone/gettimezoneenumwindows>
        """
        pulumi.set(__self__, "frequency", frequency)
        if advanced_month_days is not None:
            pulumi.set(__self__, "advanced_month_days", advanced_month_days)
        if advanced_week_days is not None:
            pulumi.set(__self__, "advanced_week_days", advanced_week_days)
        if creation_time is not None:
            pulumi.set(__self__, "creation_time", creation_time)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if expiry_time is not None:
            pulumi.set(__self__, "expiry_time", expiry_time)
        if expiry_time_offset_minutes is not None:
            pulumi.set(__self__, "expiry_time_offset_minutes", expiry_time_offset_minutes)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if last_modified_time is not None:
            pulumi.set(__self__, "last_modified_time", last_modified_time)
        if monthly_occurrence is not None:
            pulumi.set(__self__, "monthly_occurrence", monthly_occurrence)
        if next_run is not None:
            pulumi.set(__self__, "next_run", next_run)
        if next_run_offset_minutes is not None:
            pulumi.set(__self__, "next_run_offset_minutes", next_run_offset_minutes)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if start_time_offset_minutes is not None:
            pulumi.set(__self__, "start_time_offset_minutes", start_time_offset_minutes)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter
    def frequency(self) -> str:
        """
        The frequency of the schedule. - can be either `OneTime`, `Day`, `Hour`, `Week`, or `Month`.
        """
        return pulumi.get(self, "frequency")

    @property
    @pulumi.getter(name="advancedMonthDays")
    def advanced_month_days(self) -> Optional[Sequence[int]]:
        """
        List of days of the month that the job should execute on. Must be between `1` and `31`. `-1` for last day of the month. Only valid when frequency is `Month`.
        """
        return pulumi.get(self, "advanced_month_days")

    @property
    @pulumi.getter(name="advancedWeekDays")
    def advanced_week_days(self) -> Optional[Sequence[str]]:
        """
        List of days of the week that the job should execute on. Only valid when frequency is `Week`. Possible values include `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, and `Sunday`.
        """
        return pulumi.get(self, "advanced_week_days")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        A description for this Schedule.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="expiryTime")
    def expiry_time(self) -> Optional[str]:
        """
        The end time of the schedule.
        """
        return pulumi.get(self, "expiry_time")

    @property
    @pulumi.getter(name="expiryTimeOffsetMinutes")
    def expiry_time_offset_minutes(self) -> Optional[float]:
        return pulumi.get(self, "expiry_time_offset_minutes")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        The number of `frequency`s between runs. Only valid when frequency is `Day`, `Hour`, `Week`, or `Month`.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        Whether the schedule is enabled. Defaults to `true`.
        """
        return pulumi.get(self, "is_enabled")

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

    @property
    @pulumi.getter(name="monthlyOccurrence")
    def monthly_occurrence(self) -> Optional['outputs.SoftwareUpdateConfigurationScheduleMonthlyOccurrence']:
        """
        List of `monthly_occurrence` blocks as defined below to specifies occurrences of days within a month. Only valid when frequency is `Month`. The `monthly_occurrence` block supports fields as defined below.
        """
        return pulumi.get(self, "monthly_occurrence")

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

    @property
    @pulumi.getter(name="nextRunOffsetMinutes")
    def next_run_offset_minutes(self) -> Optional[float]:
        return pulumi.get(self, "next_run_offset_minutes")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        """
        Start time of the schedule. Must be at least five minutes in the future. Defaults to seven minutes in the future from the time the resource is created.
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="startTimeOffsetMinutes")
    def start_time_offset_minutes(self) -> Optional[float]:
        return pulumi.get(self, "start_time_offset_minutes")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[str]:
        """
        The timezone of the start time. Defaults to `Etc/UTC`. For possible values see: <https://docs.microsoft.com/en-us/rest/api/maps/timezone/gettimezoneenumwindows>
        """
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class SoftwareUpdateConfigurationScheduleMonthlyOccurrence(dict):
    def __init__(__self__, *,
                 day: str,
                 occurrence: int):
        """
        :param str day: Day of the occurrence. Must be one of `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, `Sunday`.
        :param int occurrence: Occurrence of the week within the month. Must be between `1` and `4`. `-1` for last week within the month.
        """
        pulumi.set(__self__, "day", day)
        pulumi.set(__self__, "occurrence", occurrence)

    @property
    @pulumi.getter
    def day(self) -> str:
        """
        Day of the occurrence. Must be one of `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, `Sunday`.
        """
        return pulumi.get(self, "day")

    @property
    @pulumi.getter
    def occurrence(self) -> int:
        """
        Occurrence of the week within the month. Must be between `1` and `4`. `-1` for last week within the month.
        """
        return pulumi.get(self, "occurrence")


@pulumi.output_type
class SoftwareUpdateConfigurationTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "azureQueries":
            suggest = "azure_queries"
        elif key == "nonAzureQueries":
            suggest = "non_azure_queries"

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

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

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

    def __init__(__self__, *,
                 azure_queries: Optional[Sequence['outputs.SoftwareUpdateConfigurationTargetAzureQuery']] = None,
                 non_azure_queries: Optional[Sequence['outputs.SoftwareUpdateConfigurationTargetNonAzureQuery']] = None):
        """
        :param Sequence['SoftwareUpdateConfigurationTargetAzureQueryArgs'] azure_queries: One or more `azure_query` blocks as defined above.
        :param Sequence['SoftwareUpdateConfigurationTargetNonAzureQueryArgs'] non_azure_queries: One or more `non_azure_query` blocks as defined above.
        """
        if azure_queries is not None:
            pulumi.set(__self__, "azure_queries", azure_queries)
        if non_azure_queries is not None:
            pulumi.set(__self__, "non_azure_queries", non_azure_queries)

    @property
    @pulumi.getter(name="azureQueries")
    def azure_queries(self) -> Optional[Sequence['outputs.SoftwareUpdateConfigurationTargetAzureQuery']]:
        """
        One or more `azure_query` blocks as defined above.
        """
        return pulumi.get(self, "azure_queries")

    @property
    @pulumi.getter(name="nonAzureQueries")
    def non_azure_queries(self) -> Optional[Sequence['outputs.SoftwareUpdateConfigurationTargetNonAzureQuery']]:
        """
        One or more `non_azure_query` blocks as defined above.
        """
        return pulumi.get(self, "non_azure_queries")


@pulumi.output_type
class SoftwareUpdateConfigurationTargetAzureQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tagFilter":
            suggest = "tag_filter"

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

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

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

    def __init__(__self__, *,
                 locations: Optional[Sequence[str]] = None,
                 scopes: Optional[Sequence[str]] = None,
                 tag_filter: Optional[str] = None,
                 tags: Optional[Sequence['outputs.SoftwareUpdateConfigurationTargetAzureQueryTag']] = None):
        """
        :param Sequence[str] locations: Specifies a list of locations to scope the query to.
        :param Sequence[str] scopes: Specifies a list of Subscription or Resource Group ARM Ids to query.
        :param str tag_filter: Specifies how the specified tags to filter VMs. Possible values are `Any` and `All`.
        :param Sequence['SoftwareUpdateConfigurationTargetAzureQueryTagArgs'] tags: A mapping of tags used for query filter. One or more `tags` block as defined below.
        """
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)
        if tag_filter is not None:
            pulumi.set(__self__, "tag_filter", tag_filter)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def locations(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of locations to scope the query to.
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter
    def scopes(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of Subscription or Resource Group ARM Ids to query.
        """
        return pulumi.get(self, "scopes")

    @property
    @pulumi.getter(name="tagFilter")
    def tag_filter(self) -> Optional[str]:
        """
        Specifies how the specified tags to filter VMs. Possible values are `Any` and `All`.
        """
        return pulumi.get(self, "tag_filter")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.SoftwareUpdateConfigurationTargetAzureQueryTag']]:
        """
        A mapping of tags used for query filter. One or more `tags` block as defined below.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class SoftwareUpdateConfigurationTargetAzureQueryTag(dict):
    def __init__(__self__, *,
                 tag: str,
                 values: Sequence[str]):
        """
        :param str tag: Specifies the name of the tag to filter.
        :param Sequence[str] values: Specifies a list of values for this tag key.
        """
        pulumi.set(__self__, "tag", tag)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def tag(self) -> str:
        """
        Specifies the name of the tag to filter.
        """
        return pulumi.get(self, "tag")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Specifies a list of values for this tag key.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class SoftwareUpdateConfigurationTargetNonAzureQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionAlias":
            suggest = "function_alias"
        elif key == "workspaceId":
            suggest = "workspace_id"

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

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

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

    def __init__(__self__, *,
                 function_alias: Optional[str] = None,
                 workspace_id: Optional[str] = None):
        """
        :param str function_alias: Specifies the Log Analytics save search name.
        :param str workspace_id: The workspace id for Log Analytics in which the saved search in.
        """
        if function_alias is not None:
            pulumi.set(__self__, "function_alias", function_alias)
        if workspace_id is not None:
            pulumi.set(__self__, "workspace_id", workspace_id)

    @property
    @pulumi.getter(name="functionAlias")
    def function_alias(self) -> Optional[str]:
        """
        Specifies the Log Analytics save search name.
        """
        return pulumi.get(self, "function_alias")

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> Optional[str]:
        """
        The workspace id for Log Analytics in which the saved search in.
        """
        return pulumi.get(self, "workspace_id")


@pulumi.output_type
class SoftwareUpdateConfigurationWindows(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "classificationsIncludeds":
            suggest = "classifications_includeds"
        elif key == "excludedKnowledgeBaseNumbers":
            suggest = "excluded_knowledge_base_numbers"
        elif key == "includedKnowledgeBaseNumbers":
            suggest = "included_knowledge_base_numbers"

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

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

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

    def __init__(__self__, *,
                 classifications_includeds: Sequence[str],
                 excluded_knowledge_base_numbers: Optional[Sequence[str]] = None,
                 included_knowledge_base_numbers: Optional[Sequence[str]] = None,
                 reboot: Optional[str] = None):
        """
        :param Sequence[str] classifications_includeds: Specifies the list of update classification. Possible values are `Unclassified`, `Critical`, `Security`, `UpdateRollup`, `FeaturePack`, `ServicePack`, `Definition`, `Tools` and `Updates`.
               
               > **NOTE:** The `classifications_included` property will become `Required` in version 4.0 of the Provider.
        :param Sequence[str] excluded_knowledge_base_numbers: Specifies a list of knowledge base numbers excluded.
        :param Sequence[str] included_knowledge_base_numbers: Specifies a list of knowledge base numbers included.
        :param str reboot: Specifies the reboot settings after software update, possible values are `IfRequired`, `Never`, `RebootOnly` and `Always`. Defaults to `IfRequired`.
        """
        pulumi.set(__self__, "classifications_includeds", classifications_includeds)
        if excluded_knowledge_base_numbers is not None:
            pulumi.set(__self__, "excluded_knowledge_base_numbers", excluded_knowledge_base_numbers)
        if included_knowledge_base_numbers is not None:
            pulumi.set(__self__, "included_knowledge_base_numbers", included_knowledge_base_numbers)
        if reboot is not None:
            pulumi.set(__self__, "reboot", reboot)

    @property
    @pulumi.getter(name="classificationsIncludeds")
    def classifications_includeds(self) -> Sequence[str]:
        """
        Specifies the list of update classification. Possible values are `Unclassified`, `Critical`, `Security`, `UpdateRollup`, `FeaturePack`, `ServicePack`, `Definition`, `Tools` and `Updates`.

        > **NOTE:** The `classifications_included` property will become `Required` in version 4.0 of the Provider.
        """
        return pulumi.get(self, "classifications_includeds")

    @property
    @pulumi.getter(name="excludedKnowledgeBaseNumbers")
    def excluded_knowledge_base_numbers(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of knowledge base numbers excluded.
        """
        return pulumi.get(self, "excluded_knowledge_base_numbers")

    @property
    @pulumi.getter(name="includedKnowledgeBaseNumbers")
    def included_knowledge_base_numbers(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of knowledge base numbers included.
        """
        return pulumi.get(self, "included_knowledge_base_numbers")

    @property
    @pulumi.getter
    def reboot(self) -> Optional[str]:
        """
        Specifies the reboot settings after software update, possible values are `IfRequired`, `Never`, `RebootOnly` and `Always`. Defaults to `IfRequired`.
        """
        return pulumi.get(self, "reboot")


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

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

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

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

    def __init__(__self__, *,
                 token: str,
                 token_type: str,
                 refresh_token: Optional[str] = None):
        """
        :param str token: The access token of specified repo.
        :param str token_type: Specify the token type, possible values are `PersonalAccessToken` and `Oauth`.
        :param str refresh_token: The refresh token of specified rpeo.
        """
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "token_type", token_type)
        if refresh_token is not None:
            pulumi.set(__self__, "refresh_token", refresh_token)

    @property
    @pulumi.getter
    def token(self) -> str:
        """
        The access token of specified repo.
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="tokenType")
    def token_type(self) -> str:
        """
        Specify the token type, possible values are `PersonalAccessToken` and `Oauth`.
        """
        return pulumi.get(self, "token_type")

    @property
    @pulumi.getter(name="refreshToken")
    def refresh_token(self) -> Optional[str]:
        """
        The refresh token of specified rpeo.
        """
        return pulumi.get(self, "refresh_token")


@pulumi.output_type
class GetAccountIdentityResult(dict):
    def __init__(__self__, *,
                 identity_ids: Sequence[str],
                 principal_id: str,
                 tenant_id: str,
                 type: str):
        """
        :param Sequence[str] identity_ids: The list of User Assigned Managed Identity IDs assigned to this Automation Account.
        :param str principal_id: The Principal ID of the System Assigned Managed Service Identity that is configured on this Automation Account.
        :param str tenant_id: The Tenant ID of the System Assigned Managed Service Identity that is configured on this Automation Account.
        :param str type: The type of Managed Service Identity that is configured on this Automation Account.
        """
        pulumi.set(__self__, "identity_ids", identity_ids)
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Sequence[str]:
        """
        The list of User Assigned Managed Identity IDs assigned to this Automation Account.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The Principal ID of the System Assigned Managed Service Identity that is configured on this Automation Account.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The Tenant ID of the System Assigned Managed Service Identity that is configured on this Automation Account.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of Managed Service Identity that is configured on this Automation Account.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetAccountPrivateEndpointConnectionResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str):
        """
        :param str id: The ID of the Automation Account
        :param str name: The name of the Automation Account.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Automation Account
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetVariablesBoolResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: bool):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param bool value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

    @property
    @pulumi.getter
    def value(self) -> bool:
        """
        The value of the Automation Variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetVariablesDatetimeResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: str):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param str value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

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


@pulumi.output_type
class GetVariablesEncryptedResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: str):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param str value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

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


@pulumi.output_type
class GetVariablesIntResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: int):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param int value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The value of the Automation Variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetVariablesNullResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: str):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param str value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

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


@pulumi.output_type
class GetVariablesObjectResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: str):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param str value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

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


@pulumi.output_type
class GetVariablesStringResult(dict):
    def __init__(__self__, *,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 value: str):
        """
        :param str description: The description of the Automation Variable.
        :param bool encrypted: Specifies if the Automation Variable is encrypted.
        :param str name: The name of the Automation Variable.
        :param str value: The value of the Automation Variable.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Specifies if the Automation Variable is encrypted.
        """
        return pulumi.get(self, "encrypted")

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

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

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


