# 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, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'GetComputeMachineAgentConfigurationResult',
    'GetComputeMachineAgentConfigurationExtensionsAllowListResult',
    'GetComputeMachineAgentConfigurationExtensionsBlockListResult',
    'GetComputeMachineCloudMetadataResult',
    'GetComputeMachineErrorDetailResult',
    'GetComputeMachineErrorDetailAdditionalInfoResult',
    'GetComputeMachineIdentityResult',
    'GetComputeMachineLocationDataResult',
    'GetComputeMachineOsProfileResult',
    'GetComputeMachineOsProfileLinuxConfigurationResult',
    'GetComputeMachineOsProfileLinuxConfigurationPatchSettingResult',
    'GetComputeMachineOsProfileWindowsConfigurationResult',
    'GetComputeMachineOsProfileWindowsConfigurationPatchSettingResult',
    'GetComputeMachineServiceStatusResult',
    'GetComputeMachineServiceStatusExtensionServiceResult',
    'GetComputeMachineServiceStatusGuestConfigurationServiceResult',
]

@pulumi.output_type
class GetComputeMachineAgentConfigurationResult(dict):
    def __init__(__self__, *,
                 extensions_allow_lists: Sequence['outputs.GetComputeMachineAgentConfigurationExtensionsAllowListResult'],
                 extensions_block_lists: Sequence['outputs.GetComputeMachineAgentConfigurationExtensionsBlockListResult'],
                 extensions_enabled: bool,
                 guest_configuration_enabled: bool,
                 incoming_connections_ports: Sequence[str],
                 proxy_bypasses: Sequence[str],
                 proxy_url: str):
        """
        :param Sequence['GetComputeMachineAgentConfigurationExtensionsAllowListArgs'] extensions_allow_lists: A `extensions_allow_list` block as defined below.
        :param Sequence['GetComputeMachineAgentConfigurationExtensionsBlockListArgs'] extensions_block_lists: A `extensions_block_list` block as defined below.
        :param bool extensions_enabled: Specifies whether the extension service is enabled or disabled.
        :param bool guest_configuration_enabled: Specified whether the guest configuration service is enabled or disabled.
        :param Sequence[str] incoming_connections_ports: Specifies the list of ports that the agent will be able to listen on.
        :param Sequence[str] proxy_bypasses: List of service names which should not use the specified proxy server.
        :param str proxy_url: Specifies the URL of the proxy to be used.
        """
        GetComputeMachineAgentConfigurationResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            extensions_allow_lists=extensions_allow_lists,
            extensions_block_lists=extensions_block_lists,
            extensions_enabled=extensions_enabled,
            guest_configuration_enabled=guest_configuration_enabled,
            incoming_connections_ports=incoming_connections_ports,
            proxy_bypasses=proxy_bypasses,
            proxy_url=proxy_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             extensions_allow_lists: Optional[Sequence['outputs.GetComputeMachineAgentConfigurationExtensionsAllowListResult']] = None,
             extensions_block_lists: Optional[Sequence['outputs.GetComputeMachineAgentConfigurationExtensionsBlockListResult']] = None,
             extensions_enabled: Optional[bool] = None,
             guest_configuration_enabled: Optional[bool] = None,
             incoming_connections_ports: Optional[Sequence[str]] = None,
             proxy_bypasses: Optional[Sequence[str]] = None,
             proxy_url: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if extensions_allow_lists is None and 'extensionsAllowLists' in kwargs:
            extensions_allow_lists = kwargs['extensionsAllowLists']
        if extensions_allow_lists is None:
            raise TypeError("Missing 'extensions_allow_lists' argument")
        if extensions_block_lists is None and 'extensionsBlockLists' in kwargs:
            extensions_block_lists = kwargs['extensionsBlockLists']
        if extensions_block_lists is None:
            raise TypeError("Missing 'extensions_block_lists' argument")
        if extensions_enabled is None and 'extensionsEnabled' in kwargs:
            extensions_enabled = kwargs['extensionsEnabled']
        if extensions_enabled is None:
            raise TypeError("Missing 'extensions_enabled' argument")
        if guest_configuration_enabled is None and 'guestConfigurationEnabled' in kwargs:
            guest_configuration_enabled = kwargs['guestConfigurationEnabled']
        if guest_configuration_enabled is None:
            raise TypeError("Missing 'guest_configuration_enabled' argument")
        if incoming_connections_ports is None and 'incomingConnectionsPorts' in kwargs:
            incoming_connections_ports = kwargs['incomingConnectionsPorts']
        if incoming_connections_ports is None:
            raise TypeError("Missing 'incoming_connections_ports' argument")
        if proxy_bypasses is None and 'proxyBypasses' in kwargs:
            proxy_bypasses = kwargs['proxyBypasses']
        if proxy_bypasses is None:
            raise TypeError("Missing 'proxy_bypasses' argument")
        if proxy_url is None and 'proxyUrl' in kwargs:
            proxy_url = kwargs['proxyUrl']
        if proxy_url is None:
            raise TypeError("Missing 'proxy_url' argument")

        _setter("extensions_allow_lists", extensions_allow_lists)
        _setter("extensions_block_lists", extensions_block_lists)
        _setter("extensions_enabled", extensions_enabled)
        _setter("guest_configuration_enabled", guest_configuration_enabled)
        _setter("incoming_connections_ports", incoming_connections_ports)
        _setter("proxy_bypasses", proxy_bypasses)
        _setter("proxy_url", proxy_url)

    @property
    @pulumi.getter(name="extensionsAllowLists")
    def extensions_allow_lists(self) -> Sequence['outputs.GetComputeMachineAgentConfigurationExtensionsAllowListResult']:
        """
        A `extensions_allow_list` block as defined below.
        """
        return pulumi.get(self, "extensions_allow_lists")

    @property
    @pulumi.getter(name="extensionsBlockLists")
    def extensions_block_lists(self) -> Sequence['outputs.GetComputeMachineAgentConfigurationExtensionsBlockListResult']:
        """
        A `extensions_block_list` block as defined below.
        """
        return pulumi.get(self, "extensions_block_lists")

    @property
    @pulumi.getter(name="extensionsEnabled")
    def extensions_enabled(self) -> bool:
        """
        Specifies whether the extension service is enabled or disabled.
        """
        return pulumi.get(self, "extensions_enabled")

    @property
    @pulumi.getter(name="guestConfigurationEnabled")
    def guest_configuration_enabled(self) -> bool:
        """
        Specified whether the guest configuration service is enabled or disabled.
        """
        return pulumi.get(self, "guest_configuration_enabled")

    @property
    @pulumi.getter(name="incomingConnectionsPorts")
    def incoming_connections_ports(self) -> Sequence[str]:
        """
        Specifies the list of ports that the agent will be able to listen on.
        """
        return pulumi.get(self, "incoming_connections_ports")

    @property
    @pulumi.getter(name="proxyBypasses")
    def proxy_bypasses(self) -> Sequence[str]:
        """
        List of service names which should not use the specified proxy server.
        """
        return pulumi.get(self, "proxy_bypasses")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> str:
        """
        Specifies the URL of the proxy to be used.
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetComputeMachineAgentConfigurationExtensionsAllowListResult(dict):
    def __init__(__self__, *,
                 publisher: str,
                 type: str):
        """
        :param str publisher: Publisher of the extension.
        :param str type: The identity type.
        """
        GetComputeMachineAgentConfigurationExtensionsAllowListResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            publisher=publisher,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             publisher: Optional[str] = None,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if publisher is None:
            raise TypeError("Missing 'publisher' argument")
        if type is None:
            raise TypeError("Missing 'type' argument")

        _setter("publisher", publisher)
        _setter("type", type)

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

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


@pulumi.output_type
class GetComputeMachineAgentConfigurationExtensionsBlockListResult(dict):
    def __init__(__self__, *,
                 publisher: str,
                 type: str):
        """
        :param str publisher: Publisher of the extension.
        :param str type: The identity type.
        """
        GetComputeMachineAgentConfigurationExtensionsBlockListResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            publisher=publisher,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             publisher: Optional[str] = None,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if publisher is None:
            raise TypeError("Missing 'publisher' argument")
        if type is None:
            raise TypeError("Missing 'type' argument")

        _setter("publisher", publisher)
        _setter("type", type)

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

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


@pulumi.output_type
class GetComputeMachineCloudMetadataResult(dict):
    def __init__(__self__, *,
                 provider: str):
        """
        :param str provider: Specifies the cloud provider. For example `Azure`, `AWS` and `GCP`.
        """
        GetComputeMachineCloudMetadataResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            provider=provider,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             provider: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if provider is None:
            raise TypeError("Missing 'provider' argument")

        _setter("provider", provider)

    @property
    @pulumi.getter
    def provider(self) -> str:
        """
        Specifies the cloud provider. For example `Azure`, `AWS` and `GCP`.
        """
        return pulumi.get(self, "provider")


@pulumi.output_type
class GetComputeMachineErrorDetailResult(dict):
    def __init__(__self__, *,
                 additional_infos: Sequence['outputs.GetComputeMachineErrorDetailAdditionalInfoResult'],
                 code: str,
                 message: str,
                 target: str):
        """
        :param Sequence['GetComputeMachineErrorDetailAdditionalInfoArgs'] additional_infos: A `additional_info` block as defined above.
        :param str code: The error code.
        :param str message: The error message.
        :param str target: The error target.
        """
        GetComputeMachineErrorDetailResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            additional_infos=additional_infos,
            code=code,
            message=message,
            target=target,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             additional_infos: Optional[Sequence['outputs.GetComputeMachineErrorDetailAdditionalInfoResult']] = None,
             code: Optional[str] = None,
             message: Optional[str] = None,
             target: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if additional_infos is None and 'additionalInfos' in kwargs:
            additional_infos = kwargs['additionalInfos']
        if additional_infos is None:
            raise TypeError("Missing 'additional_infos' argument")
        if code is None:
            raise TypeError("Missing 'code' argument")
        if message is None:
            raise TypeError("Missing 'message' argument")
        if target is None:
            raise TypeError("Missing 'target' argument")

        _setter("additional_infos", additional_infos)
        _setter("code", code)
        _setter("message", message)
        _setter("target", target)

    @property
    @pulumi.getter(name="additionalInfos")
    def additional_infos(self) -> Sequence['outputs.GetComputeMachineErrorDetailAdditionalInfoResult']:
        """
        A `additional_info` block as defined above.
        """
        return pulumi.get(self, "additional_infos")

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

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

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


@pulumi.output_type
class GetComputeMachineErrorDetailAdditionalInfoResult(dict):
    def __init__(__self__, *,
                 info: str,
                 type: str):
        """
        :param str info: The additional information message.
        :param str type: The identity type.
        """
        GetComputeMachineErrorDetailAdditionalInfoResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            info=info,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             info: Optional[str] = None,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if info is None:
            raise TypeError("Missing 'info' argument")
        if type is None:
            raise TypeError("Missing 'type' argument")

        _setter("info", info)
        _setter("type", type)

    @property
    @pulumi.getter
    def info(self) -> str:
        """
        The additional information message.
        """
        return pulumi.get(self, "info")

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


@pulumi.output_type
class GetComputeMachineIdentityResult(dict):
    def __init__(__self__, *,
                 principal_id: str,
                 tenant_id: str,
                 type: str):
        """
        :param str principal_id: The principal ID of resource identity.
        :param str tenant_id: The tenant ID of resource.
        :param str type: The identity type.
        """
        GetComputeMachineIdentityResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            principal_id=principal_id,
            tenant_id=tenant_id,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             principal_id: Optional[str] = None,
             tenant_id: Optional[str] = None,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if principal_id is None and 'principalId' in kwargs:
            principal_id = kwargs['principalId']
        if principal_id is None:
            raise TypeError("Missing 'principal_id' argument")
        if tenant_id is None and 'tenantId' in kwargs:
            tenant_id = kwargs['tenantId']
        if tenant_id is None:
            raise TypeError("Missing 'tenant_id' argument")
        if type is None:
            raise TypeError("Missing 'type' argument")

        _setter("principal_id", principal_id)
        _setter("tenant_id", tenant_id)
        _setter("type", type)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The principal ID of resource identity.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The tenant ID of resource.
        """
        return pulumi.get(self, "tenant_id")

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


@pulumi.output_type
class GetComputeMachineLocationDataResult(dict):
    def __init__(__self__, *,
                 city: str,
                 country_or_region: str,
                 district: str,
                 name: str):
        """
        :param str city: The city or locality where the resource is located.
        :param str country_or_region: The country or region where the resource is located.
        :param str district: The district, state, or province where the resource is located.
        :param str name: The name of this hybrid compute machine.
        """
        GetComputeMachineLocationDataResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            city=city,
            country_or_region=country_or_region,
            district=district,
            name=name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             city: Optional[str] = None,
             country_or_region: Optional[str] = None,
             district: Optional[str] = None,
             name: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if city is None:
            raise TypeError("Missing 'city' argument")
        if country_or_region is None and 'countryOrRegion' in kwargs:
            country_or_region = kwargs['countryOrRegion']
        if country_or_region is None:
            raise TypeError("Missing 'country_or_region' argument")
        if district is None:
            raise TypeError("Missing 'district' argument")
        if name is None:
            raise TypeError("Missing 'name' argument")

        _setter("city", city)
        _setter("country_or_region", country_or_region)
        _setter("district", district)
        _setter("name", name)

    @property
    @pulumi.getter
    def city(self) -> str:
        """
        The city or locality where the resource is located.
        """
        return pulumi.get(self, "city")

    @property
    @pulumi.getter(name="countryOrRegion")
    def country_or_region(self) -> str:
        """
        The country or region where the resource is located.
        """
        return pulumi.get(self, "country_or_region")

    @property
    @pulumi.getter
    def district(self) -> str:
        """
        The district, state, or province where the resource is located.
        """
        return pulumi.get(self, "district")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of this hybrid compute machine.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetComputeMachineOsProfileResult(dict):
    def __init__(__self__, *,
                 computer_name: str,
                 linux_configurations: Sequence['outputs.GetComputeMachineOsProfileLinuxConfigurationResult'],
                 windows_configurations: Sequence['outputs.GetComputeMachineOsProfileWindowsConfigurationResult']):
        """
        :param str computer_name: Specifies the host OS name of the hybrid machine.
        :param Sequence['GetComputeMachineOsProfileLinuxConfigurationArgs'] linux_configurations: A `linux_configuration` block as defined above.
        :param Sequence['GetComputeMachineOsProfileWindowsConfigurationArgs'] windows_configurations: A `windows_configuration` block as defined below.
        """
        GetComputeMachineOsProfileResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            computer_name=computer_name,
            linux_configurations=linux_configurations,
            windows_configurations=windows_configurations,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             computer_name: Optional[str] = None,
             linux_configurations: Optional[Sequence['outputs.GetComputeMachineOsProfileLinuxConfigurationResult']] = None,
             windows_configurations: Optional[Sequence['outputs.GetComputeMachineOsProfileWindowsConfigurationResult']] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if computer_name is None and 'computerName' in kwargs:
            computer_name = kwargs['computerName']
        if computer_name is None:
            raise TypeError("Missing 'computer_name' argument")
        if linux_configurations is None and 'linuxConfigurations' in kwargs:
            linux_configurations = kwargs['linuxConfigurations']
        if linux_configurations is None:
            raise TypeError("Missing 'linux_configurations' argument")
        if windows_configurations is None and 'windowsConfigurations' in kwargs:
            windows_configurations = kwargs['windowsConfigurations']
        if windows_configurations is None:
            raise TypeError("Missing 'windows_configurations' argument")

        _setter("computer_name", computer_name)
        _setter("linux_configurations", linux_configurations)
        _setter("windows_configurations", windows_configurations)

    @property
    @pulumi.getter(name="computerName")
    def computer_name(self) -> str:
        """
        Specifies the host OS name of the hybrid machine.
        """
        return pulumi.get(self, "computer_name")

    @property
    @pulumi.getter(name="linuxConfigurations")
    def linux_configurations(self) -> Sequence['outputs.GetComputeMachineOsProfileLinuxConfigurationResult']:
        """
        A `linux_configuration` block as defined above.
        """
        return pulumi.get(self, "linux_configurations")

    @property
    @pulumi.getter(name="windowsConfigurations")
    def windows_configurations(self) -> Sequence['outputs.GetComputeMachineOsProfileWindowsConfigurationResult']:
        """
        A `windows_configuration` block as defined below.
        """
        return pulumi.get(self, "windows_configurations")


@pulumi.output_type
class GetComputeMachineOsProfileLinuxConfigurationResult(dict):
    def __init__(__self__, *,
                 patch_settings: Sequence['outputs.GetComputeMachineOsProfileLinuxConfigurationPatchSettingResult']):
        """
        :param Sequence['GetComputeMachineOsProfileLinuxConfigurationPatchSettingArgs'] patch_settings: A `patch_settings` block as defined above.
        """
        GetComputeMachineOsProfileLinuxConfigurationResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            patch_settings=patch_settings,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             patch_settings: Optional[Sequence['outputs.GetComputeMachineOsProfileLinuxConfigurationPatchSettingResult']] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if patch_settings is None and 'patchSettings' in kwargs:
            patch_settings = kwargs['patchSettings']
        if patch_settings is None:
            raise TypeError("Missing 'patch_settings' argument")

        _setter("patch_settings", patch_settings)

    @property
    @pulumi.getter(name="patchSettings")
    def patch_settings(self) -> Sequence['outputs.GetComputeMachineOsProfileLinuxConfigurationPatchSettingResult']:
        """
        A `patch_settings` block as defined above.
        """
        return pulumi.get(self, "patch_settings")


@pulumi.output_type
class GetComputeMachineOsProfileLinuxConfigurationPatchSettingResult(dict):
    def __init__(__self__, *,
                 assessment_mode: str,
                 patch_mode: str):
        """
        :param str assessment_mode: Specifies the assessment mode.
        :param str patch_mode: Specifies the patch mode.
        """
        GetComputeMachineOsProfileLinuxConfigurationPatchSettingResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            assessment_mode=assessment_mode,
            patch_mode=patch_mode,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             assessment_mode: Optional[str] = None,
             patch_mode: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if assessment_mode is None and 'assessmentMode' in kwargs:
            assessment_mode = kwargs['assessmentMode']
        if assessment_mode is None:
            raise TypeError("Missing 'assessment_mode' argument")
        if patch_mode is None and 'patchMode' in kwargs:
            patch_mode = kwargs['patchMode']
        if patch_mode is None:
            raise TypeError("Missing 'patch_mode' argument")

        _setter("assessment_mode", assessment_mode)
        _setter("patch_mode", patch_mode)

    @property
    @pulumi.getter(name="assessmentMode")
    def assessment_mode(self) -> str:
        """
        Specifies the assessment mode.
        """
        return pulumi.get(self, "assessment_mode")

    @property
    @pulumi.getter(name="patchMode")
    def patch_mode(self) -> str:
        """
        Specifies the patch mode.
        """
        return pulumi.get(self, "patch_mode")


@pulumi.output_type
class GetComputeMachineOsProfileWindowsConfigurationResult(dict):
    def __init__(__self__, *,
                 patch_settings: Sequence['outputs.GetComputeMachineOsProfileWindowsConfigurationPatchSettingResult']):
        """
        :param Sequence['GetComputeMachineOsProfileWindowsConfigurationPatchSettingArgs'] patch_settings: A `patch_settings` block as defined above.
        """
        GetComputeMachineOsProfileWindowsConfigurationResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            patch_settings=patch_settings,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             patch_settings: Optional[Sequence['outputs.GetComputeMachineOsProfileWindowsConfigurationPatchSettingResult']] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if patch_settings is None and 'patchSettings' in kwargs:
            patch_settings = kwargs['patchSettings']
        if patch_settings is None:
            raise TypeError("Missing 'patch_settings' argument")

        _setter("patch_settings", patch_settings)

    @property
    @pulumi.getter(name="patchSettings")
    def patch_settings(self) -> Sequence['outputs.GetComputeMachineOsProfileWindowsConfigurationPatchSettingResult']:
        """
        A `patch_settings` block as defined above.
        """
        return pulumi.get(self, "patch_settings")


@pulumi.output_type
class GetComputeMachineOsProfileWindowsConfigurationPatchSettingResult(dict):
    def __init__(__self__, *,
                 assessment_mode: str,
                 patch_mode: str):
        """
        :param str assessment_mode: Specifies the assessment mode.
        :param str patch_mode: Specifies the patch mode.
        """
        GetComputeMachineOsProfileWindowsConfigurationPatchSettingResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            assessment_mode=assessment_mode,
            patch_mode=patch_mode,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             assessment_mode: Optional[str] = None,
             patch_mode: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if assessment_mode is None and 'assessmentMode' in kwargs:
            assessment_mode = kwargs['assessmentMode']
        if assessment_mode is None:
            raise TypeError("Missing 'assessment_mode' argument")
        if patch_mode is None and 'patchMode' in kwargs:
            patch_mode = kwargs['patchMode']
        if patch_mode is None:
            raise TypeError("Missing 'patch_mode' argument")

        _setter("assessment_mode", assessment_mode)
        _setter("patch_mode", patch_mode)

    @property
    @pulumi.getter(name="assessmentMode")
    def assessment_mode(self) -> str:
        """
        Specifies the assessment mode.
        """
        return pulumi.get(self, "assessment_mode")

    @property
    @pulumi.getter(name="patchMode")
    def patch_mode(self) -> str:
        """
        Specifies the patch mode.
        """
        return pulumi.get(self, "patch_mode")


@pulumi.output_type
class GetComputeMachineServiceStatusResult(dict):
    def __init__(__self__, *,
                 extension_services: Sequence['outputs.GetComputeMachineServiceStatusExtensionServiceResult'],
                 guest_configuration_services: Sequence['outputs.GetComputeMachineServiceStatusGuestConfigurationServiceResult']):
        """
        :param Sequence['GetComputeMachineServiceStatusExtensionServiceArgs'] extension_services: A `extension_service` block as defined above.
        :param Sequence['GetComputeMachineServiceStatusGuestConfigurationServiceArgs'] guest_configuration_services: A `guest_configuration_service` block as defined above.
        """
        GetComputeMachineServiceStatusResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            extension_services=extension_services,
            guest_configuration_services=guest_configuration_services,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             extension_services: Optional[Sequence['outputs.GetComputeMachineServiceStatusExtensionServiceResult']] = None,
             guest_configuration_services: Optional[Sequence['outputs.GetComputeMachineServiceStatusGuestConfigurationServiceResult']] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if extension_services is None and 'extensionServices' in kwargs:
            extension_services = kwargs['extensionServices']
        if extension_services is None:
            raise TypeError("Missing 'extension_services' argument")
        if guest_configuration_services is None and 'guestConfigurationServices' in kwargs:
            guest_configuration_services = kwargs['guestConfigurationServices']
        if guest_configuration_services is None:
            raise TypeError("Missing 'guest_configuration_services' argument")

        _setter("extension_services", extension_services)
        _setter("guest_configuration_services", guest_configuration_services)

    @property
    @pulumi.getter(name="extensionServices")
    def extension_services(self) -> Sequence['outputs.GetComputeMachineServiceStatusExtensionServiceResult']:
        """
        A `extension_service` block as defined above.
        """
        return pulumi.get(self, "extension_services")

    @property
    @pulumi.getter(name="guestConfigurationServices")
    def guest_configuration_services(self) -> Sequence['outputs.GetComputeMachineServiceStatusGuestConfigurationServiceResult']:
        """
        A `guest_configuration_service` block as defined above.
        """
        return pulumi.get(self, "guest_configuration_services")


@pulumi.output_type
class GetComputeMachineServiceStatusExtensionServiceResult(dict):
    def __init__(__self__, *,
                 startup_type: str,
                 status: str):
        """
        :param str startup_type: The behavior of the service when the Arc-enabled machine starts up.
        :param str status: The current status of the service.
        """
        GetComputeMachineServiceStatusExtensionServiceResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            startup_type=startup_type,
            status=status,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             startup_type: Optional[str] = None,
             status: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if startup_type is None and 'startupType' in kwargs:
            startup_type = kwargs['startupType']
        if startup_type is None:
            raise TypeError("Missing 'startup_type' argument")
        if status is None:
            raise TypeError("Missing 'status' argument")

        _setter("startup_type", startup_type)
        _setter("status", status)

    @property
    @pulumi.getter(name="startupType")
    def startup_type(self) -> str:
        """
        The behavior of the service when the Arc-enabled machine starts up.
        """
        return pulumi.get(self, "startup_type")

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


@pulumi.output_type
class GetComputeMachineServiceStatusGuestConfigurationServiceResult(dict):
    def __init__(__self__, *,
                 startup_type: str,
                 status: str):
        """
        :param str startup_type: The behavior of the service when the Arc-enabled machine starts up.
        :param str status: The current status of the service.
        """
        GetComputeMachineServiceStatusGuestConfigurationServiceResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            startup_type=startup_type,
            status=status,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             startup_type: Optional[str] = None,
             status: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if startup_type is None and 'startupType' in kwargs:
            startup_type = kwargs['startupType']
        if startup_type is None:
            raise TypeError("Missing 'startup_type' argument")
        if status is None:
            raise TypeError("Missing 'status' argument")

        _setter("startup_type", startup_type)
        _setter("status", status)

    @property
    @pulumi.getter(name="startupType")
    def startup_type(self) -> str:
        """
        The behavior of the service when the Arc-enabled machine starts up.
        """
        return pulumi.get(self, "startup_type")

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


