pulumi-azure-native 3.6.0a1751063629__py3-none-any.whl → 3.6.1__py3-none-any.whl

pulumi_azure_native/edge/outputs.py

@@ -15,331 +15,2979 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
+from ._enums import *
 
 __all__ = [
+    'AvailableSolutionTemplateVersionResponse',
+    'AzureResourceManagerCommonTypesExtendedLocationResponse',
+    'CapabilityResponse',
+    'ComponentStatusResponse',
+    'ConfigTemplatePropertiesResponse',
+    'ConfigurationPropertiesResponse',
+    'ConfigurationReferencePropertiesResponse',
+    'ContextPropertiesResponse',
+    'DeploymentStatusResponse',
+    'DiagnosticPropertiesResponse',
+    'DynamicConfigurationPropertiesResponse',
+    'DynamicConfigurationVersionPropertiesResponse',
+    'DynamicSchemaPropertiesResponse',
+    'ErrorActionResponse',
+    'ErrorAdditionalInfoResponse',
+    'ErrorDetailResponse',
+    'ExecutionPropertiesResponse',
+    'ExecutionStatusResponse',
+    'HierarchyResponse',
+    'InstancePropertiesResponse',
+    'ReconciliationPolicyPropertiesResponse',
+    'SchemaPropertiesResponse',
+    'SchemaVersionPropertiesResponse',
     'SiteAddressPropertiesResponse',
     'SitePropertiesResponse',
+    'SiteReferencePropertiesResponse',
+    'SolutionDependencyResponse',
+    'SolutionPropertiesResponse',
+    'SolutionTemplatePropertiesResponse',
+    'SolutionVersionPropertiesResponse',
+    'StageSpecResponse',
+    'StageStatusResponse',
     'SystemDataResponse',
+    'TargetPropertiesResponse',
+    'TargetStatusResponse',
+    'TaskOptionResponse',
+    'TaskSpecResponse',
+    'WorkflowPropertiesResponse',
+    'WorkflowVersionPropertiesResponse',
 ]
 
+@pulumi.output_type
+class AvailableSolutionTemplateVersionResponse(dict):
+    """
+    Available Solution template Version along with latest revision
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "isConfigured":
+            suggest = "is_configured"
+        elif key == "latestConfigRevision":
+            suggest = "latest_config_revision"
+        elif key == "solutionTemplateVersion":
+            suggest = "solution_template_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AvailableSolutionTemplateVersionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AvailableSolutionTemplateVersionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AvailableSolutionTemplateVersionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 is_configured: builtins.bool,
+                 latest_config_revision: builtins.str,
+                 solution_template_version: builtins.str):
+        """
+        Available Solution template Version along with latest revision
+        :param builtins.bool is_configured: Has this solution template version been configured
+        :param builtins.str latest_config_revision: Latest Configuration Revision
+        :param builtins.str solution_template_version: Solution template Version
+        """
+        pulumi.set(__self__, "is_configured", is_configured)
+        pulumi.set(__self__, "latest_config_revision", latest_config_revision)
+        pulumi.set(__self__, "solution_template_version", solution_template_version)
+
+    @property
+    @pulumi.getter(name="isConfigured")
+    def is_configured(self) -> builtins.bool:
+        """
+        Has this solution template version been configured
+        """
+        return pulumi.get(self, "is_configured")
+
+    @property
+    @pulumi.getter(name="latestConfigRevision")
+    def latest_config_revision(self) -> builtins.str:
+        """
+        Latest Configuration Revision
+        """
+        return pulumi.get(self, "latest_config_revision")
+
+    @property
+    @pulumi.getter(name="solutionTemplateVersion")
+    def solution_template_version(self) -> builtins.str:
+        """
+        Solution template Version
+        """
+        return pulumi.get(self, "solution_template_version")
+
+
+@pulumi.output_type
+class AzureResourceManagerCommonTypesExtendedLocationResponse(dict):
+    """
+    The complex type of the extended location.
+    """
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 type: builtins.str):
+        """
+        The complex type of the extended location.
+        :param builtins.str name: The name of the extended location.
+        :param builtins.str type: The type of the extended location.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        The name of the extended location.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> builtins.str:
+        """
+        The type of the extended location.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class CapabilityResponse(dict):
+    """
+    Capability, to match in Solution Templates & Targets
+    """
+    def __init__(__self__, *,
+                 description: builtins.str,
+                 name: builtins.str,
+                 state: Optional[builtins.str] = None):
+        """
+        Capability, to match in Solution Templates & Targets
+        :param builtins.str description: Description of Capability
+        :param builtins.str name: Name of Capability
+        :param builtins.str state: State of resource
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "name", name)
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def description(self) -> builtins.str:
+        """
+        Description of Capability
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of Capability
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[builtins.str]:
+        """
+        State of resource
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class ComponentStatusResponse(dict):
+    """
+    Component Status
+    """
+    def __init__(__self__, *,
+                 name: Optional[builtins.str] = None,
+                 status: Optional[builtins.str] = None):
+        """
+        Component Status
+        :param builtins.str name: Component name
+        :param builtins.str status: Component status
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[builtins.str]:
+        """
+        Component name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[builtins.str]:
+        """
+        Component status
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class ConfigTemplatePropertiesResponse(dict):
+    """
+    Config Template Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "latestVersion":
+            suggest = "latest_version"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConfigTemplatePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConfigTemplatePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConfigTemplatePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 description: builtins.str,
+                 latest_version: builtins.str,
+                 provisioning_state: builtins.str):
+        """
+        Config Template Properties
+        :param builtins.str description: Description of config template
+        :param builtins.str latest_version: Latest config template version
+        :param builtins.str provisioning_state: Provisioning state of resource
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "latest_version", latest_version)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter
+    def description(self) -> builtins.str:
+        """
+        Description of config template
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="latestVersion")
+    def latest_version(self) -> builtins.str:
+        """
+        Latest config template version
+        """
+        return pulumi.get(self, "latest_version")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class ConfigurationPropertiesResponse(dict):
+    """
+    Configuration Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConfigurationPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConfigurationPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConfigurationPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str):
+        """
+        Configuration Properties
+        :param builtins.str provisioning_state: Provisioning state of resource
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class ConfigurationReferencePropertiesResponse(dict):
+    """
+    Properties for ConfigurationReference Resource
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "configurationResourceId":
+            suggest = "configuration_resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConfigurationReferencePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConfigurationReferencePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConfigurationReferencePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 configuration_resource_id: Optional[builtins.str] = None):
+        """
+        Properties for ConfigurationReference Resource
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str configuration_resource_id: ArmId of Configuration resource
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if configuration_resource_id is not None:
+            pulumi.set(__self__, "configuration_resource_id", configuration_resource_id)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="configurationResourceId")
+    def configuration_resource_id(self) -> Optional[builtins.str]:
+        """
+        ArmId of Configuration resource
+        """
+        return pulumi.get(self, "configuration_resource_id")
+
+
+@pulumi.output_type
+class ContextPropertiesResponse(dict):
+    """
+    Context Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ContextPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ContextPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ContextPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 capabilities: Sequence['outputs.CapabilityResponse'],
+                 hierarchies: Sequence['outputs.HierarchyResponse'],
+                 provisioning_state: builtins.str):
+        """
+        Context Properties
+        :param Sequence['CapabilityResponse'] capabilities: List of Capabilities
+        :param Sequence['HierarchyResponse'] hierarchies: List of Hierarchies
+        :param builtins.str provisioning_state: Provisioning state of resource
+        """
+        pulumi.set(__self__, "capabilities", capabilities)
+        pulumi.set(__self__, "hierarchies", hierarchies)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter
+    def capabilities(self) -> Sequence['outputs.CapabilityResponse']:
+        """
+        List of Capabilities
+        """
+        return pulumi.get(self, "capabilities")
+
+    @property
+    @pulumi.getter
+    def hierarchies(self) -> Sequence['outputs.HierarchyResponse']:
+        """
+        List of Hierarchies
+        """
+        return pulumi.get(self, "hierarchies")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class DeploymentStatusResponse(dict):
+    """
+    Deployment Status
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "expectedRunningJobId":
+            suggest = "expected_running_job_id"
+        elif key == "lastModified":
+            suggest = "last_modified"
+        elif key == "runningJobId":
+            suggest = "running_job_id"
+        elif key == "statusDetails":
+            suggest = "status_details"
+        elif key == "targetStatuses":
+            suggest = "target_statuses"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DeploymentStatusResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DeploymentStatusResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DeploymentStatusResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 deployed: Optional[builtins.int] = None,
+                 expected_running_job_id: Optional[builtins.int] = None,
+                 generation: Optional[builtins.int] = None,
+                 last_modified: Optional[builtins.str] = None,
+                 running_job_id: Optional[builtins.int] = None,
+                 status: Optional[builtins.str] = None,
+                 status_details: Optional[builtins.str] = None,
+                 target_statuses: Optional[Sequence['outputs.TargetStatusResponse']] = None):
+        """
+        Deployment Status
+        :param builtins.int deployed: Indicates if Instance is deployed
+        :param builtins.int expected_running_job_id: The expected running job id
+        :param builtins.int generation: Deployment Generation
+        :param builtins.str last_modified: The lastModified of the Status
+        :param builtins.int running_job_id: The running job id
+        :param builtins.str status: Deployment status
+        :param builtins.str status_details: Status details
+        :param Sequence['TargetStatusResponse'] target_statuses: Target resource statuses
+        """
+        if deployed is not None:
+            pulumi.set(__self__, "deployed", deployed)
+        if expected_running_job_id is not None:
+            pulumi.set(__self__, "expected_running_job_id", expected_running_job_id)
+        if generation is not None:
+            pulumi.set(__self__, "generation", generation)
+        if last_modified is not None:
+            pulumi.set(__self__, "last_modified", last_modified)
+        if running_job_id is not None:
+            pulumi.set(__self__, "running_job_id", running_job_id)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if status_details is not None:
+            pulumi.set(__self__, "status_details", status_details)
+        if target_statuses is not None:
+            pulumi.set(__self__, "target_statuses", target_statuses)
+
+    @property
+    @pulumi.getter
+    def deployed(self) -> Optional[builtins.int]:
+        """
+        Indicates if Instance is deployed
+        """
+        return pulumi.get(self, "deployed")
+
+    @property
+    @pulumi.getter(name="expectedRunningJobId")
+    def expected_running_job_id(self) -> Optional[builtins.int]:
+        """
+        The expected running job id
+        """
+        return pulumi.get(self, "expected_running_job_id")
+
+    @property
+    @pulumi.getter
+    def generation(self) -> Optional[builtins.int]:
+        """
+        Deployment Generation
+        """
+        return pulumi.get(self, "generation")
+
+    @property
+    @pulumi.getter(name="lastModified")
+    def last_modified(self) -> Optional[builtins.str]:
+        """
+        The lastModified of the Status
+        """
+        return pulumi.get(self, "last_modified")
+
+    @property
+    @pulumi.getter(name="runningJobId")
+    def running_job_id(self) -> Optional[builtins.int]:
+        """
+        The running job id
+        """
+        return pulumi.get(self, "running_job_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[builtins.str]:
+        """
+        Deployment status
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="statusDetails")
+    def status_details(self) -> Optional[builtins.str]:
+        """
+        Status details
+        """
+        return pulumi.get(self, "status_details")
+
+    @property
+    @pulumi.getter(name="targetStatuses")
+    def target_statuses(self) -> Optional[Sequence['outputs.TargetStatusResponse']]:
+        """
+        Target resource statuses
+        """
+        return pulumi.get(self, "target_statuses")
+
+
+@pulumi.output_type
+class DiagnosticPropertiesResponse(dict):
+    """
+    The properties of a Diagnostic resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DiagnosticPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DiagnosticPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DiagnosticPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str):
+        """
+        The properties of a Diagnostic resource.
+        :param builtins.str provisioning_state: The status of the last operation.
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class DynamicConfigurationPropertiesResponse(dict):
+    """
+    Dynamic Configuration Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "currentVersion":
+            suggest = "current_version"
+        elif key == "dynamicConfigurationModel":
+            suggest = "dynamic_configuration_model"
+        elif key == "dynamicConfigurationType":
+            suggest = "dynamic_configuration_type"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicConfigurationPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicConfigurationPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicConfigurationPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 current_version: builtins.str,
+                 dynamic_configuration_model: builtins.str,
+                 dynamic_configuration_type: builtins.str,
+                 provisioning_state: builtins.str):
+        """
+        Dynamic Configuration Properties
+        :param builtins.str current_version: Current Version of dynamic configuration
+        :param builtins.str dynamic_configuration_model: Type of dynamic configuration model
+        :param builtins.str dynamic_configuration_type: Type of dynamic configuration
+        :param builtins.str provisioning_state: Provisioning state of resource
+        """
+        pulumi.set(__self__, "current_version", current_version)
+        pulumi.set(__self__, "dynamic_configuration_model", dynamic_configuration_model)
+        pulumi.set(__self__, "dynamic_configuration_type", dynamic_configuration_type)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter(name="currentVersion")
+    def current_version(self) -> builtins.str:
+        """
+        Current Version of dynamic configuration
+        """
+        return pulumi.get(self, "current_version")
+
+    @property
+    @pulumi.getter(name="dynamicConfigurationModel")
+    def dynamic_configuration_model(self) -> builtins.str:
+        """
+        Type of dynamic configuration model
+        """
+        return pulumi.get(self, "dynamic_configuration_model")
+
+    @property
+    @pulumi.getter(name="dynamicConfigurationType")
+    def dynamic_configuration_type(self) -> builtins.str:
+        """
+        Type of dynamic configuration
+        """
+        return pulumi.get(self, "dynamic_configuration_type")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class DynamicConfigurationVersionPropertiesResponse(dict):
+    """
+    Dynamic Configuration Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "schemaId":
+            suggest = "schema_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicConfigurationVersionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicConfigurationVersionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicConfigurationVersionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 schema_id: builtins.str,
+                 values: builtins.str):
+        """
+        Dynamic Configuration Properties
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str schema_id: Schema Id for configuration
+        :param builtins.str values: Values of configuration version
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "schema_id", schema_id)
+        pulumi.set(__self__, "values", values)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="schemaId")
+    def schema_id(self) -> builtins.str:
+        """
+        Schema Id for configuration
+        """
+        return pulumi.get(self, "schema_id")
+
+    @property
+    @pulumi.getter
+    def values(self) -> builtins.str:
+        """
+        Values of configuration version
+        """
+        return pulumi.get(self, "values")
+
+
+@pulumi.output_type
+class DynamicSchemaPropertiesResponse(dict):
+    """
+    DynamicSchema Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "configurationModel":
+            suggest = "configuration_model"
+        elif key == "configurationType":
+            suggest = "configuration_type"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicSchemaPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicSchemaPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicSchemaPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 configuration_model: builtins.str,
+                 configuration_type: builtins.str,
+                 provisioning_state: builtins.str):
+        """
+        DynamicSchema Properties
+        :param builtins.str configuration_model: Type of configuration model
+        :param builtins.str configuration_type: Type of configuration
+        :param builtins.str provisioning_state: Provisioning state of resource
+        """
+        pulumi.set(__self__, "configuration_model", configuration_model)
+        pulumi.set(__self__, "configuration_type", configuration_type)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter(name="configurationModel")
+    def configuration_model(self) -> builtins.str:
+        """
+        Type of configuration model
+        """
+        return pulumi.get(self, "configuration_model")
+
+    @property
+    @pulumi.getter(name="configurationType")
+    def configuration_type(self) -> builtins.str:
+        """
+        Type of configuration
+        """
+        return pulumi.get(self, "configuration_type")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class ErrorActionResponse(dict):
+    """
+    Error Action Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxToleratedFailures":
+            suggest = "max_tolerated_failures"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ErrorActionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ErrorActionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ErrorActionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_tolerated_failures: Optional[builtins.int] = None,
+                 mode: Optional[builtins.str] = None):
+        """
+        Error Action Properties
+        :param builtins.int max_tolerated_failures: Max tolerated failures
+        :param builtins.str mode: Error action mode
+        """
+        if max_tolerated_failures is not None:
+            pulumi.set(__self__, "max_tolerated_failures", max_tolerated_failures)
+        if mode is None:
+            mode = 'stopOnAnyFailure'
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+
+    @property
+    @pulumi.getter(name="maxToleratedFailures")
+    def max_tolerated_failures(self) -> Optional[builtins.int]:
+        """
+        Max tolerated failures
+        """
+        return pulumi.get(self, "max_tolerated_failures")
+
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[builtins.str]:
+        """
+        Error action mode
+        """
+        return pulumi.get(self, "mode")
+
+
+@pulumi.output_type
+class ErrorAdditionalInfoResponse(dict):
+    """
+    The resource management error additional info.
+    """
+    def __init__(__self__, *,
+                 info: Any,
+                 type: builtins.str):
+        """
+        The resource management error additional info.
+        :param Any info: The additional info.
+        :param builtins.str type: The additional info type.
+        """
+        pulumi.set(__self__, "info", info)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def info(self) -> Any:
+        """
+        The additional info.
+        """
+        return pulumi.get(self, "info")
+
+    @property
+    @pulumi.getter
+    def type(self) -> builtins.str:
+        """
+        The additional info type.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class ErrorDetailResponse(dict):
+    """
+    The error detail.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "additionalInfo":
+            suggest = "additional_info"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ErrorDetailResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ErrorDetailResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ErrorDetailResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 additional_info: Sequence['outputs.ErrorAdditionalInfoResponse'],
+                 code: builtins.str,
+                 details: Sequence['outputs.ErrorDetailResponse'],
+                 message: builtins.str,
+                 target: builtins.str):
+        """
+        The error detail.
+        :param Sequence['ErrorAdditionalInfoResponse'] additional_info: The error additional info.
+        :param builtins.str code: The error code.
+        :param Sequence['ErrorDetailResponse'] details: The error details.
+        :param builtins.str message: The error message.
+        :param builtins.str target: The error target.
+        """
+        pulumi.set(__self__, "additional_info", additional_info)
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "details", details)
+        pulumi.set(__self__, "message", message)
+        pulumi.set(__self__, "target", target)
+
+    @property
+    @pulumi.getter(name="additionalInfo")
+    def additional_info(self) -> Sequence['outputs.ErrorAdditionalInfoResponse']:
+        """
+        The error additional info.
+        """
+        return pulumi.get(self, "additional_info")
+
+    @property
+    @pulumi.getter
+    def code(self) -> builtins.str:
+        """
+        The error code.
+        """
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter
+    def details(self) -> Sequence['outputs.ErrorDetailResponse']:
+        """
+        The error details.
+        """
+        return pulumi.get(self, "details")
+
+    @property
+    @pulumi.getter
+    def message(self) -> builtins.str:
+        """
+        The error message.
+        """
+        return pulumi.get(self, "message")
+
+    @property
+    @pulumi.getter
+    def target(self) -> builtins.str:
+        """
+        The error target.
+        """
+        return pulumi.get(self, "target")
+
+
+@pulumi.output_type
+class ExecutionPropertiesResponse(dict):
+    """
+    Execution Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "workflowVersionId":
+            suggest = "workflow_version_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExecutionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExecutionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExecutionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 status: 'outputs.ExecutionStatusResponse',
+                 workflow_version_id: builtins.str,
+                 specification: Optional[Any] = None):
+        """
+        Execution Properties
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param 'ExecutionStatusResponse' status: Status of Execution
+        :param builtins.str workflow_version_id: Workflow version of execution
+        :param Any specification: Execution specification
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "workflow_version_id", workflow_version_id)
+        if specification is not None:
+            pulumi.set(__self__, "specification", specification)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def status(self) -> 'outputs.ExecutionStatusResponse':
+        """
+        Status of Execution
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="workflowVersionId")
+    def workflow_version_id(self) -> builtins.str:
+        """
+        Workflow version of execution
+        """
+        return pulumi.get(self, "workflow_version_id")
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Optional[Any]:
+        """
+        Execution specification
+        """
+        return pulumi.get(self, "specification")
+
+
+@pulumi.output_type
+class ExecutionStatusResponse(dict):
+    """
+    Execution Status
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "stageHistory":
+            suggest = "stage_history"
+        elif key == "statusMessage":
+            suggest = "status_message"
+        elif key == "updateTime":
+            suggest = "update_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExecutionStatusResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExecutionStatusResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExecutionStatusResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 stage_history: Optional[Sequence['outputs.StageStatusResponse']] = None,
+                 status: Optional[builtins.int] = None,
+                 status_message: Optional[builtins.str] = None,
+                 update_time: Optional[builtins.str] = None):
+        """
+        Execution Status
+        :param Sequence['StageStatusResponse'] stage_history: target resource statuses
+        :param builtins.int status: Deployment status
+        :param builtins.str status_message: status details
+        :param builtins.str update_time: The lastModified timestamp of the Status
+        """
+        if stage_history is not None:
+            pulumi.set(__self__, "stage_history", stage_history)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if status_message is not None:
+            pulumi.set(__self__, "status_message", status_message)
+        if update_time is not None:
+            pulumi.set(__self__, "update_time", update_time)
+
+    @property
+    @pulumi.getter(name="stageHistory")
+    def stage_history(self) -> Optional[Sequence['outputs.StageStatusResponse']]:
+        """
+        target resource statuses
+        """
+        return pulumi.get(self, "stage_history")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[builtins.int]:
+        """
+        Deployment status
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="statusMessage")
+    def status_message(self) -> Optional[builtins.str]:
+        """
+        status details
+        """
+        return pulumi.get(self, "status_message")
+
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> Optional[builtins.str]:
+        """
+        The lastModified timestamp of the Status
+        """
+        return pulumi.get(self, "update_time")
+
+
+@pulumi.output_type
+class HierarchyResponse(dict):
+    """
+    Hierarchy, to tag Sites / Hierarchy Provider nodes with what they represent
+    """
+    def __init__(__self__, *,
+                 description: builtins.str,
+                 name: builtins.str):
+        """
+        Hierarchy, to tag Sites / Hierarchy Provider nodes with what they represent
+        :param builtins.str description: Description of Hierarchy
+        :param builtins.str name: Name of Hierarchy
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def description(self) -> builtins.str:
+        """
+        Description of Hierarchy
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of Hierarchy
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class InstancePropertiesResponse(dict):
+    """
+    Instance Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deploymentTimestampEpoch":
+            suggest = "deployment_timestamp_epoch"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "solutionVersionId":
+            suggest = "solution_version_id"
+        elif key == "targetId":
+            suggest = "target_id"
+        elif key == "activeState":
+            suggest = "active_state"
+        elif key == "reconciliationPolicy":
+            suggest = "reconciliation_policy"
+        elif key == "solutionScope":
+            suggest = "solution_scope"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstancePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstancePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstancePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 deployment_timestamp_epoch: builtins.float,
+                 provisioning_state: builtins.str,
+                 solution_version_id: builtins.str,
+                 status: 'outputs.DeploymentStatusResponse',
+                 target_id: builtins.str,
+                 active_state: Optional[builtins.str] = None,
+                 reconciliation_policy: Optional['outputs.ReconciliationPolicyPropertiesResponse'] = None,
+                 solution_scope: Optional[builtins.str] = None):
+        """
+        Instance Properties
+        :param builtins.float deployment_timestamp_epoch: Deployment timestamp of instance
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str solution_version_id: Solution version of instance
+        :param 'DeploymentStatusResponse' status: Status of instance
+        :param builtins.str target_id: Target of instance
+        :param builtins.str active_state: State of instance
+        :param 'ReconciliationPolicyPropertiesResponse' reconciliation_policy: Reconciliation policy of instance
+        :param builtins.str solution_scope: Scope of instance
+        """
+        pulumi.set(__self__, "deployment_timestamp_epoch", deployment_timestamp_epoch)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "solution_version_id", solution_version_id)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "target_id", target_id)
+        if active_state is not None:
+            pulumi.set(__self__, "active_state", active_state)
+        if reconciliation_policy is not None:
+            pulumi.set(__self__, "reconciliation_policy", reconciliation_policy)
+        if solution_scope is not None:
+            pulumi.set(__self__, "solution_scope", solution_scope)
+
+    @property
+    @pulumi.getter(name="deploymentTimestampEpoch")
+    def deployment_timestamp_epoch(self) -> builtins.float:
+        """
+        Deployment timestamp of instance
+        """
+        return pulumi.get(self, "deployment_timestamp_epoch")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="solutionVersionId")
+    def solution_version_id(self) -> builtins.str:
+        """
+        Solution version of instance
+        """
+        return pulumi.get(self, "solution_version_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> 'outputs.DeploymentStatusResponse':
+        """
+        Status of instance
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="targetId")
+    def target_id(self) -> builtins.str:
+        """
+        Target of instance
+        """
+        return pulumi.get(self, "target_id")
+
+    @property
+    @pulumi.getter(name="activeState")
+    def active_state(self) -> Optional[builtins.str]:
+        """
+        State of instance
+        """
+        return pulumi.get(self, "active_state")
+
+    @property
+    @pulumi.getter(name="reconciliationPolicy")
+    def reconciliation_policy(self) -> Optional['outputs.ReconciliationPolicyPropertiesResponse']:
+        """
+        Reconciliation policy of instance
+        """
+        return pulumi.get(self, "reconciliation_policy")
+
+    @property
+    @pulumi.getter(name="solutionScope")
+    def solution_scope(self) -> Optional[builtins.str]:
+        """
+        Scope of instance
+        """
+        return pulumi.get(self, "solution_scope")
+
+
+@pulumi.output_type
+class ReconciliationPolicyPropertiesResponse(dict):
+    """
+    Defines a ReconciliationPolicy
+    """
+    def __init__(__self__, *,
+                 interval: builtins.str,
+                 state: builtins.str):
+        """
+        Defines a ReconciliationPolicy
+        :param builtins.str interval: Policy interval
+        :param builtins.str state: The state of the ReconciliationPolicy
+        """
+        pulumi.set(__self__, "interval", interval)
+        pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def interval(self) -> builtins.str:
+        """
+        Policy interval
+        """
+        return pulumi.get(self, "interval")
+
+    @property
+    @pulumi.getter
+    def state(self) -> builtins.str:
+        """
+        The state of the ReconciliationPolicy
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class SchemaPropertiesResponse(dict):
+    """
+    Schema Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "currentVersion":
+            suggest = "current_version"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SchemaPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SchemaPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SchemaPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 current_version: builtins.str,
+                 provisioning_state: builtins.str):
+        """
+        Schema Properties
+        :param builtins.str current_version: Current Version of schema
+        :param builtins.str provisioning_state: Provisioning state of resource
+        """
+        pulumi.set(__self__, "current_version", current_version)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter(name="currentVersion")
+    def current_version(self) -> builtins.str:
+        """
+        Current Version of schema
+        """
+        return pulumi.get(self, "current_version")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+
+@pulumi.output_type
+class SchemaVersionPropertiesResponse(dict):
+    """
+    Schema Version Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SchemaVersionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SchemaVersionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SchemaVersionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 value: builtins.str):
+        """
+        Schema Version Properties
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str value: Value of schema version
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def value(self) -> builtins.str:
+        """
+        Value of schema version
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class SiteAddressPropertiesResponse(dict):
     """
-    Site address properties
+    Site address properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "postalCode":
+            suggest = "postal_code"
+        elif key == "stateOrProvince":
+            suggest = "state_or_province"
+        elif key == "streetAddress1":
+            suggest = "street_address1"
+        elif key == "streetAddress2":
+            suggest = "street_address2"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteAddressPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteAddressPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteAddressPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 city: Optional[builtins.str] = None,
+                 country: Optional[builtins.str] = None,
+                 postal_code: Optional[builtins.str] = None,
+                 state_or_province: Optional[builtins.str] = None,
+                 street_address1: Optional[builtins.str] = None,
+                 street_address2: Optional[builtins.str] = None):
+        """
+        Site address properties
+        :param builtins.str city: City of the address
+        :param builtins.str country: Country of the address
+        :param builtins.str postal_code: Postal or ZIP code of the address
+        :param builtins.str state_or_province: State or province of the address
+        :param builtins.str street_address1: First line of the street address
+        :param builtins.str street_address2: Second line of the street address
+        """
+        if city is not None:
+            pulumi.set(__self__, "city", city)
+        if country is not None:
+            pulumi.set(__self__, "country", country)
+        if postal_code is not None:
+            pulumi.set(__self__, "postal_code", postal_code)
+        if state_or_province is not None:
+            pulumi.set(__self__, "state_or_province", state_or_province)
+        if street_address1 is not None:
+            pulumi.set(__self__, "street_address1", street_address1)
+        if street_address2 is not None:
+            pulumi.set(__self__, "street_address2", street_address2)
+
+    @property
+    @pulumi.getter
+    def city(self) -> Optional[builtins.str]:
+        """
+        City of the address
+        """
+        return pulumi.get(self, "city")
+
+    @property
+    @pulumi.getter
+    def country(self) -> Optional[builtins.str]:
+        """
+        Country of the address
+        """
+        return pulumi.get(self, "country")
+
+    @property
+    @pulumi.getter(name="postalCode")
+    def postal_code(self) -> Optional[builtins.str]:
+        """
+        Postal or ZIP code of the address
+        """
+        return pulumi.get(self, "postal_code")
+
+    @property
+    @pulumi.getter(name="stateOrProvince")
+    def state_or_province(self) -> Optional[builtins.str]:
+        """
+        State or province of the address
+        """
+        return pulumi.get(self, "state_or_province")
+
+    @property
+    @pulumi.getter(name="streetAddress1")
+    def street_address1(self) -> Optional[builtins.str]:
+        """
+        First line of the street address
+        """
+        return pulumi.get(self, "street_address1")
+
+    @property
+    @pulumi.getter(name="streetAddress2")
+    def street_address2(self) -> Optional[builtins.str]:
+        """
+        Second line of the street address
+        """
+        return pulumi.get(self, "street_address2")
+
+
+@pulumi.output_type
+class SitePropertiesResponse(dict):
+    """
+    Site properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "addressResourceId":
+            suggest = "address_resource_id"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "siteAddress":
+            suggest = "site_address"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SitePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SitePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SitePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 address_resource_id: Optional[builtins.str] = None,
+                 description: Optional[builtins.str] = None,
+                 display_name: Optional[builtins.str] = None,
+                 labels: Optional[Mapping[str, builtins.str]] = None,
+                 site_address: Optional['outputs.SiteAddressPropertiesResponse'] = None):
+        """
+        Site properties
+        :param builtins.str provisioning_state: Provisioning state of last operation
+        :param builtins.str address_resource_id: AddressResource ArmId of Site resource
+        :param builtins.str description: Description of Site resource
+        :param builtins.str display_name: displayName of Site resource
+        :param Mapping[str, builtins.str] labels: Key-value pairs for labeling the site resource.
+        :param 'SiteAddressPropertiesResponse' site_address: Physical address of the site
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if address_resource_id is not None:
+            pulumi.set(__self__, "address_resource_id", address_resource_id)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if labels is not None:
+            pulumi.set(__self__, "labels", labels)
+        if site_address is not None:
+            pulumi.set(__self__, "site_address", site_address)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of last operation
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="addressResourceId")
+    def address_resource_id(self) -> Optional[builtins.str]:
+        """
+        AddressResource ArmId of Site resource
+        """
+        return pulumi.get(self, "address_resource_id")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[builtins.str]:
+        """
+        Description of Site resource
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        displayName of Site resource
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        Key-value pairs for labeling the site resource.
+        """
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter(name="siteAddress")
+    def site_address(self) -> Optional['outputs.SiteAddressPropertiesResponse']:
+        """
+        Physical address of the site
+        """
+        return pulumi.get(self, "site_address")
+
+
+@pulumi.output_type
+class SiteReferencePropertiesResponse(dict):
+    """
+    Site Reference Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "siteId":
+            suggest = "site_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteReferencePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteReferencePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteReferencePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 site_id: builtins.str):
+        """
+        Site Reference Properties
+        :param builtins.str provisioning_state: Provisioning State
+        :param builtins.str site_id: Azure Resource ID for Site
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "site_id", site_id)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning State
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="siteId")
+    def site_id(self) -> builtins.str:
+        """
+        Azure Resource ID for Site
+        """
+        return pulumi.get(self, "site_id")
+
+
+@pulumi.output_type
+class SolutionDependencyResponse(dict):
+    """
+    Solution Dependency Context
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "solutionTemplateVersionId":
+            suggest = "solution_template_version_id"
+        elif key == "solutionVersionId":
+            suggest = "solution_version_id"
+        elif key == "targetId":
+            suggest = "target_id"
+        elif key == "solutionInstanceName":
+            suggest = "solution_instance_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SolutionDependencyResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SolutionDependencyResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SolutionDependencyResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 solution_template_version_id: builtins.str,
+                 solution_version_id: builtins.str,
+                 target_id: builtins.str,
+                 dependencies: Optional[Sequence['outputs.SolutionDependencyResponse']] = None,
+                 solution_instance_name: Optional[builtins.str] = None):
+        """
+        Solution Dependency Context
+        :param builtins.str solution_template_version_id: Solution Template Version Id
+        :param builtins.str solution_version_id: Solution Version Id
+        :param builtins.str target_id: Target Id
+        :param Sequence['SolutionDependencyResponse'] dependencies: Solution dependencies
+        :param builtins.str solution_instance_name: Solution Instance Name
+        """
+        pulumi.set(__self__, "solution_template_version_id", solution_template_version_id)
+        pulumi.set(__self__, "solution_version_id", solution_version_id)
+        pulumi.set(__self__, "target_id", target_id)
+        if dependencies is not None:
+            pulumi.set(__self__, "dependencies", dependencies)
+        if solution_instance_name is not None:
+            pulumi.set(__self__, "solution_instance_name", solution_instance_name)
+
+    @property
+    @pulumi.getter(name="solutionTemplateVersionId")
+    def solution_template_version_id(self) -> builtins.str:
+        """
+        Solution Template Version Id
+        """
+        return pulumi.get(self, "solution_template_version_id")
+
+    @property
+    @pulumi.getter(name="solutionVersionId")
+    def solution_version_id(self) -> builtins.str:
+        """
+        Solution Version Id
+        """
+        return pulumi.get(self, "solution_version_id")
+
+    @property
+    @pulumi.getter(name="targetId")
+    def target_id(self) -> builtins.str:
+        """
+        Target Id
+        """
+        return pulumi.get(self, "target_id")
+
+    @property
+    @pulumi.getter
+    def dependencies(self) -> Optional[Sequence['outputs.SolutionDependencyResponse']]:
+        """
+        Solution dependencies
+        """
+        return pulumi.get(self, "dependencies")
+
+    @property
+    @pulumi.getter(name="solutionInstanceName")
+    def solution_instance_name(self) -> Optional[builtins.str]:
+        """
+        Solution Instance Name
+        """
+        return pulumi.get(self, "solution_instance_name")
+
+
+@pulumi.output_type
+class SolutionPropertiesResponse(dict):
+    """
+    Solution Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "availableSolutionTemplateVersions":
+            suggest = "available_solution_template_versions"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "solutionTemplateId":
+            suggest = "solution_template_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SolutionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SolutionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SolutionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 available_solution_template_versions: Sequence['outputs.AvailableSolutionTemplateVersionResponse'],
+                 provisioning_state: builtins.str,
+                 solution_template_id: builtins.str):
+        """
+        Solution Properties
+        :param Sequence['AvailableSolutionTemplateVersionResponse'] available_solution_template_versions: List of latest revisions for available solution template versions
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str solution_template_id: Solution template Id
+        """
+        pulumi.set(__self__, "available_solution_template_versions", available_solution_template_versions)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "solution_template_id", solution_template_id)
+
+    @property
+    @pulumi.getter(name="availableSolutionTemplateVersions")
+    def available_solution_template_versions(self) -> Sequence['outputs.AvailableSolutionTemplateVersionResponse']:
+        """
+        List of latest revisions for available solution template versions
+        """
+        return pulumi.get(self, "available_solution_template_versions")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="solutionTemplateId")
+    def solution_template_id(self) -> builtins.str:
+        """
+        Solution template Id
+        """
+        return pulumi.get(self, "solution_template_id")
+
+
+@pulumi.output_type
+class SolutionTemplatePropertiesResponse(dict):
+    """
+    Solution Template Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "latestVersion":
+            suggest = "latest_version"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "enableExternalValidation":
+            suggest = "enable_external_validation"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SolutionTemplatePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SolutionTemplatePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SolutionTemplatePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 capabilities: Sequence[builtins.str],
+                 description: builtins.str,
+                 latest_version: builtins.str,
+                 provisioning_state: builtins.str,
+                 enable_external_validation: Optional[builtins.bool] = None,
+                 state: Optional[builtins.str] = None):
+        """
+        Solution Template Properties
+        :param Sequence[builtins.str] capabilities: List of capabilities
+        :param builtins.str description: Description of Solution template
+        :param builtins.str latest_version: Latest solution template version
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.bool enable_external_validation: Flag to enable external validation
+        :param builtins.str state: State of resource
+        """
+        pulumi.set(__self__, "capabilities", capabilities)
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "latest_version", latest_version)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if enable_external_validation is not None:
+            pulumi.set(__self__, "enable_external_validation", enable_external_validation)
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def capabilities(self) -> Sequence[builtins.str]:
+        """
+        List of capabilities
+        """
+        return pulumi.get(self, "capabilities")
+
+    @property
+    @pulumi.getter
+    def description(self) -> builtins.str:
+        """
+        Description of Solution template
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="latestVersion")
+    def latest_version(self) -> builtins.str:
+        """
+        Latest solution template version
+        """
+        return pulumi.get(self, "latest_version")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="enableExternalValidation")
+    def enable_external_validation(self) -> Optional[builtins.bool]:
+        """
+        Flag to enable external validation
+        """
+        return pulumi.get(self, "enable_external_validation")
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[builtins.str]:
+        """
+        State of resource
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class SolutionVersionPropertiesResponse(dict):
+    """
+    Solution Version Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionType":
+            suggest = "action_type"
+        elif key == "errorDetails":
+            suggest = "error_details"
+        elif key == "externalValidationId":
+            suggest = "external_validation_id"
+        elif key == "latestActionTrackingUri":
+            suggest = "latest_action_tracking_uri"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "reviewId":
+            suggest = "review_id"
+        elif key == "solutionDependencies":
+            suggest = "solution_dependencies"
+        elif key == "solutionInstanceName":
+            suggest = "solution_instance_name"
+        elif key == "solutionTemplateVersionId":
+            suggest = "solution_template_version_id"
+        elif key == "targetDisplayName":
+            suggest = "target_display_name"
+        elif key == "targetLevelConfiguration":
+            suggest = "target_level_configuration"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SolutionVersionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SolutionVersionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SolutionVersionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action_type: builtins.str,
+                 configuration: builtins.str,
+                 error_details: 'outputs.ErrorDetailResponse',
+                 external_validation_id: builtins.str,
+                 latest_action_tracking_uri: builtins.str,
+                 provisioning_state: builtins.str,
+                 review_id: builtins.str,
+                 revision: builtins.int,
+                 solution_dependencies: Sequence['outputs.SolutionDependencyResponse'],
+                 solution_instance_name: builtins.str,
+                 solution_template_version_id: builtins.str,
+                 specification: Any,
+                 state: builtins.str,
+                 target_display_name: builtins.str,
+                 target_level_configuration: builtins.str):
+        """
+        Solution Version Properties
+        :param builtins.str action_type: The type of the latest action performed on this solution version.
+        :param builtins.str configuration: Resolved configuration values
+        :param 'ErrorDetailResponse' error_details: Error Details if any failure is there
+        :param builtins.str external_validation_id: External validation id
+        :param builtins.str latest_action_tracking_uri: The URI for tracking the latest action performed on this solution version.
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str review_id: Review id of resolved config for this solution version
+        :param builtins.int revision: Revision number of resolved config for this solution version
+        :param Sequence['SolutionDependencyResponse'] solution_dependencies: Solution Dependency Context
+        :param builtins.str solution_instance_name: Solution instance name
+        :param builtins.str solution_template_version_id: Solution Template Version Id
+        :param Any specification: App components spec
+        :param builtins.str state: State of solution instance
+        :param builtins.str target_display_name: Name of applicable target's display name
+        :param builtins.str target_level_configuration: Configuration on the line level across all solution template versions
+        """
+        pulumi.set(__self__, "action_type", action_type)
+        pulumi.set(__self__, "configuration", configuration)
+        pulumi.set(__self__, "error_details", error_details)
+        pulumi.set(__self__, "external_validation_id", external_validation_id)
+        pulumi.set(__self__, "latest_action_tracking_uri", latest_action_tracking_uri)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "review_id", review_id)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "solution_dependencies", solution_dependencies)
+        pulumi.set(__self__, "solution_instance_name", solution_instance_name)
+        pulumi.set(__self__, "solution_template_version_id", solution_template_version_id)
+        pulumi.set(__self__, "specification", specification)
+        pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "target_display_name", target_display_name)
+        pulumi.set(__self__, "target_level_configuration", target_level_configuration)
+
+    @property
+    @pulumi.getter(name="actionType")
+    def action_type(self) -> builtins.str:
+        """
+        The type of the latest action performed on this solution version.
+        """
+        return pulumi.get(self, "action_type")
+
+    @property
+    @pulumi.getter
+    def configuration(self) -> builtins.str:
+        """
+        Resolved configuration values
+        """
+        return pulumi.get(self, "configuration")
+
+    @property
+    @pulumi.getter(name="errorDetails")
+    def error_details(self) -> 'outputs.ErrorDetailResponse':
+        """
+        Error Details if any failure is there
+        """
+        return pulumi.get(self, "error_details")
+
+    @property
+    @pulumi.getter(name="externalValidationId")
+    def external_validation_id(self) -> builtins.str:
+        """
+        External validation id
+        """
+        return pulumi.get(self, "external_validation_id")
+
+    @property
+    @pulumi.getter(name="latestActionTrackingUri")
+    def latest_action_tracking_uri(self) -> builtins.str:
+        """
+        The URI for tracking the latest action performed on this solution version.
+        """
+        return pulumi.get(self, "latest_action_tracking_uri")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="reviewId")
+    def review_id(self) -> builtins.str:
+        """
+        Review id of resolved config for this solution version
+        """
+        return pulumi.get(self, "review_id")
+
+    @property
+    @pulumi.getter
+    def revision(self) -> builtins.int:
+        """
+        Revision number of resolved config for this solution version
+        """
+        return pulumi.get(self, "revision")
+
+    @property
+    @pulumi.getter(name="solutionDependencies")
+    def solution_dependencies(self) -> Sequence['outputs.SolutionDependencyResponse']:
+        """
+        Solution Dependency Context
+        """
+        return pulumi.get(self, "solution_dependencies")
+
+    @property
+    @pulumi.getter(name="solutionInstanceName")
+    def solution_instance_name(self) -> builtins.str:
+        """
+        Solution instance name
+        """
+        return pulumi.get(self, "solution_instance_name")
+
+    @property
+    @pulumi.getter(name="solutionTemplateVersionId")
+    def solution_template_version_id(self) -> builtins.str:
+        """
+        Solution Template Version Id
+        """
+        return pulumi.get(self, "solution_template_version_id")
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Any:
+        """
+        App components spec
+        """
+        return pulumi.get(self, "specification")
+
+    @property
+    @pulumi.getter
+    def state(self) -> builtins.str:
+        """
+        State of solution instance
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="targetDisplayName")
+    def target_display_name(self) -> builtins.str:
+        """
+        Name of applicable target's display name
+        """
+        return pulumi.get(self, "target_display_name")
+
+    @property
+    @pulumi.getter(name="targetLevelConfiguration")
+    def target_level_configuration(self) -> builtins.str:
+        """
+        Configuration on the line level across all solution template versions
+        """
+        return pulumi.get(self, "target_level_configuration")
+
+
+@pulumi.output_type
+class StageSpecResponse(dict):
+    """
+    Stage Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "taskOption":
+            suggest = "task_option"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StageSpecResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StageSpecResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StageSpecResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 specification: Optional[Any] = None,
+                 task_option: Optional['outputs.TaskOptionResponse'] = None,
+                 tasks: Optional[Sequence['outputs.TaskSpecResponse']] = None):
+        """
+        Stage Properties
+        :param builtins.str name: Name of Stage
+        :param Any specification: Stage specification
+        :param 'TaskOptionResponse' task_option: Task option for the stage
+        :param Sequence['TaskSpecResponse'] tasks: List of tasks in the stage
+        """
+        pulumi.set(__self__, "name", name)
+        if specification is not None:
+            pulumi.set(__self__, "specification", specification)
+        if task_option is not None:
+            pulumi.set(__self__, "task_option", task_option)
+        if tasks is not None:
+            pulumi.set(__self__, "tasks", tasks)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of Stage
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Optional[Any]:
+        """
+        Stage specification
+        """
+        return pulumi.get(self, "specification")
+
+    @property
+    @pulumi.getter(name="taskOption")
+    def task_option(self) -> Optional['outputs.TaskOptionResponse']:
+        """
+        Task option for the stage
+        """
+        return pulumi.get(self, "task_option")
+
+    @property
+    @pulumi.getter
+    def tasks(self) -> Optional[Sequence['outputs.TaskSpecResponse']]:
+        """
+        List of tasks in the stage
+        """
+        return pulumi.get(self, "tasks")
+
+
+@pulumi.output_type
+class StageStatusResponse(dict):
+    """
+    Result of Stage execution
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "errorMessage":
+            suggest = "error_message"
+        elif key == "isActive":
+            suggest = "is_active"
+        elif key == "statusMessage":
+            suggest = "status_message"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StageStatusResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StageStatusResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StageStatusResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 error_message: Optional[builtins.str] = None,
+                 inputs: Optional[Any] = None,
+                 is_active: Optional[builtins.str] = None,
+                 nextstage: Optional[builtins.str] = None,
+                 outputs: Optional[Any] = None,
+                 stage: Optional[builtins.str] = None,
+                 status: Optional[builtins.int] = None,
+                 status_message: Optional[builtins.str] = None):
+        """
+        Result of Stage execution
+        :param builtins.str error_message: Error message
+        :param Any inputs: The inputs of the StageHistory, Inputs holds a key-value map of user-defined parameters for the initial stage
+        :param builtins.str is_active: whether this stage is active or inactive
+        :param builtins.str nextstage: Next stage
+        :param Any outputs: The outputs of the StageHistory, it is different as the different input stages.
+        :param builtins.str stage: Current stage
+        :param builtins.int status: Deployment status
+        :param builtins.str status_message: Status message
+        """
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+        if inputs is not None:
+            pulumi.set(__self__, "inputs", inputs)
+        if is_active is not None:
+            pulumi.set(__self__, "is_active", is_active)
+        if nextstage is not None:
+            pulumi.set(__self__, "nextstage", nextstage)
+        if outputs is not None:
+            pulumi.set(__self__, "outputs", outputs)
+        if stage is not None:
+            pulumi.set(__self__, "stage", stage)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if status_message is not None:
+            pulumi.set(__self__, "status_message", status_message)
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[builtins.str]:
+        """
+        Error message
+        """
+        return pulumi.get(self, "error_message")
+
+    @property
+    @pulumi.getter
+    def inputs(self) -> Optional[Any]:
+        """
+        The inputs of the StageHistory, Inputs holds a key-value map of user-defined parameters for the initial stage
+        """
+        return pulumi.get(self, "inputs")
+
+    @property
+    @pulumi.getter(name="isActive")
+    def is_active(self) -> Optional[builtins.str]:
+        """
+        whether this stage is active or inactive
+        """
+        return pulumi.get(self, "is_active")
+
+    @property
+    @pulumi.getter
+    def nextstage(self) -> Optional[builtins.str]:
+        """
+        Next stage
+        """
+        return pulumi.get(self, "nextstage")
+
+    @property
+    @pulumi.getter
+    def outputs(self) -> Optional[Any]:
+        """
+        The outputs of the StageHistory, it is different as the different input stages.
+        """
+        return pulumi.get(self, "outputs")
+
+    @property
+    @pulumi.getter
+    def stage(self) -> Optional[builtins.str]:
+        """
+        Current stage
+        """
+        return pulumi.get(self, "stage")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[builtins.int]:
+        """
+        Deployment status
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="statusMessage")
+    def status_message(self) -> Optional[builtins.str]:
+        """
+        Status message
+        """
+        return pulumi.get(self, "status_message")
+
+
+@pulumi.output_type
+class SystemDataResponse(dict):
+    """
+    Metadata pertaining to creation and last modification of the resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createdAt":
+            suggest = "created_at"
+        elif key == "createdBy":
+            suggest = "created_by"
+        elif key == "createdByType":
+            suggest = "created_by_type"
+        elif key == "lastModifiedAt":
+            suggest = "last_modified_at"
+        elif key == "lastModifiedBy":
+            suggest = "last_modified_by"
+        elif key == "lastModifiedByType":
+            suggest = "last_modified_by_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SystemDataResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 created_at: Optional[builtins.str] = None,
+                 created_by: Optional[builtins.str] = None,
+                 created_by_type: Optional[builtins.str] = None,
+                 last_modified_at: Optional[builtins.str] = None,
+                 last_modified_by: Optional[builtins.str] = None,
+                 last_modified_by_type: Optional[builtins.str] = None):
+        """
+        Metadata pertaining to creation and last modification of the resource.
+        :param builtins.str created_at: The timestamp of resource creation (UTC).
+        :param builtins.str created_by: The identity that created the resource.
+        :param builtins.str created_by_type: The type of identity that created the resource.
+        :param builtins.str last_modified_at: The timestamp of resource last modification (UTC)
+        :param builtins.str last_modified_by: The identity that last modified the resource.
+        :param builtins.str last_modified_by_type: The type of identity that last modified the resource.
+        """
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_by_type is not None:
+            pulumi.set(__self__, "created_by_type", created_by_type)
+        if last_modified_at is not None:
+            pulumi.set(__self__, "last_modified_at", last_modified_at)
+        if last_modified_by is not None:
+            pulumi.set(__self__, "last_modified_by", last_modified_by)
+        if last_modified_by_type is not None:
+            pulumi.set(__self__, "last_modified_by_type", last_modified_by_type)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[builtins.str]:
+        """
+        The timestamp of resource creation (UTC).
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[builtins.str]:
+        """
+        The identity that created the resource.
+        """
+        return pulumi.get(self, "created_by")
+
+    @property
+    @pulumi.getter(name="createdByType")
+    def created_by_type(self) -> Optional[builtins.str]:
+        """
+        The type of identity that created the resource.
+        """
+        return pulumi.get(self, "created_by_type")
+
+    @property
+    @pulumi.getter(name="lastModifiedAt")
+    def last_modified_at(self) -> Optional[builtins.str]:
+        """
+        The timestamp of resource last modification (UTC)
+        """
+        return pulumi.get(self, "last_modified_at")
+
+    @property
+    @pulumi.getter(name="lastModifiedBy")
+    def last_modified_by(self) -> Optional[builtins.str]:
+        """
+        The identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by")
+
+    @property
+    @pulumi.getter(name="lastModifiedByType")
+    def last_modified_by_type(self) -> Optional[builtins.str]:
+        """
+        The type of identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by_type")
+
+
+@pulumi.output_type
+class TargetPropertiesResponse(dict):
+    """
+    Target Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "contextId":
+            suggest = "context_id"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "hierarchyLevel":
+            suggest = "hierarchy_level"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "targetSpecification":
+            suggest = "target_specification"
+        elif key == "solutionScope":
+            suggest = "solution_scope"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TargetPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TargetPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TargetPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 capabilities: Sequence[builtins.str],
+                 context_id: builtins.str,
+                 description: builtins.str,
+                 display_name: builtins.str,
+                 hierarchy_level: builtins.str,
+                 provisioning_state: builtins.str,
+                 status: 'outputs.DeploymentStatusResponse',
+                 target_specification: Any,
+                 solution_scope: Optional[builtins.str] = None,
+                 state: Optional[builtins.str] = None):
+        """
+        Target Properties
+        :param Sequence[builtins.str] capabilities: List of capabilities
+        :param builtins.str context_id: ArmId of Context
+        :param builtins.str description: Description of target
+        :param builtins.str display_name: Display name of target
+        :param builtins.str hierarchy_level: Hierarchy Level
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param 'DeploymentStatusResponse' status: Status of target
+        :param Any target_specification: target spec
+        :param builtins.str solution_scope: Scope of the target resource
+        :param builtins.str state: State of resource
+        """
+        pulumi.set(__self__, "capabilities", capabilities)
+        pulumi.set(__self__, "context_id", context_id)
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "display_name", display_name)
+        pulumi.set(__self__, "hierarchy_level", hierarchy_level)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "target_specification", target_specification)
+        if solution_scope is not None:
+            pulumi.set(__self__, "solution_scope", solution_scope)
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def capabilities(self) -> Sequence[builtins.str]:
+        """
+        List of capabilities
+        """
+        return pulumi.get(self, "capabilities")
+
+    @property
+    @pulumi.getter(name="contextId")
+    def context_id(self) -> builtins.str:
+        """
+        ArmId of Context
+        """
+        return pulumi.get(self, "context_id")
+
+    @property
+    @pulumi.getter
+    def description(self) -> builtins.str:
+        """
+        Description of target
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> builtins.str:
+        """
+        Display name of target
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter(name="hierarchyLevel")
+    def hierarchy_level(self) -> builtins.str:
+        """
+        Hierarchy Level
+        """
+        return pulumi.get(self, "hierarchy_level")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        Provisioning state of resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def status(self) -> 'outputs.DeploymentStatusResponse':
+        """
+        Status of target
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="targetSpecification")
+    def target_specification(self) -> Any:
+        """
+        target spec
+        """
+        return pulumi.get(self, "target_specification")
+
+    @property
+    @pulumi.getter(name="solutionScope")
+    def solution_scope(self) -> Optional[builtins.str]:
+        """
+        Scope of the target resource
+        """
+        return pulumi.get(self, "solution_scope")
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[builtins.str]:
+        """
+        State of resource
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class TargetStatusResponse(dict):
+    """
+    Target Status
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "postalCode":
-            suggest = "postal_code"
-        elif key == "stateOrProvince":
-            suggest = "state_or_province"
-        elif key == "streetAddress1":
-            suggest = "street_address1"
-        elif key == "streetAddress2":
-            suggest = "street_address2"
+        if key == "componentStatuses":
+            suggest = "component_statuses"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SiteAddressPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in TargetStatusResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        SiteAddressPropertiesResponse.__key_warning(key)
+        TargetStatusResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        SiteAddressPropertiesResponse.__key_warning(key)
+        TargetStatusResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 city: Optional[builtins.str] = None,
-                 country: Optional[builtins.str] = None,
-                 postal_code: Optional[builtins.str] = None,
-                 state_or_province: Optional[builtins.str] = None,
-                 street_address1: Optional[builtins.str] = None,
-                 street_address2: Optional[builtins.str] = None):
+                 component_statuses: Optional[Sequence['outputs.ComponentStatusResponse']] = None,
+                 name: Optional[builtins.str] = None,
+                 status: Optional[builtins.str] = None):
         """
-        Site address properties
-        :param builtins.str city: City of the address
-        :param builtins.str country: Country of the address
-        :param builtins.str postal_code: Postal or ZIP code of the address
-        :param builtins.str state_or_province: State or province of the address
-        :param builtins.str street_address1: First line of the street address
-        :param builtins.str street_address2: Second line of the street address
+        Target Status
+        :param Sequence['ComponentStatusResponse'] component_statuses: Component statuses
+        :param builtins.str name: Target name
+        :param builtins.str status: Target status
         """
-        if city is not None:
-            pulumi.set(__self__, "city", city)
-        if country is not None:
-            pulumi.set(__self__, "country", country)
-        if postal_code is not None:
-            pulumi.set(__self__, "postal_code", postal_code)
-        if state_or_province is not None:
-            pulumi.set(__self__, "state_or_province", state_or_province)
-        if street_address1 is not None:
-            pulumi.set(__self__, "street_address1", street_address1)
-        if street_address2 is not None:
-            pulumi.set(__self__, "street_address2", street_address2)
+        if component_statuses is not None:
+            pulumi.set(__self__, "component_statuses", component_statuses)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
 
     @property
-    @pulumi.getter
-    def city(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="componentStatuses")
+    def component_statuses(self) -> Optional[Sequence['outputs.ComponentStatusResponse']]:
         """
-        City of the address
+        Component statuses
         """
-        return pulumi.get(self, "city")
+        return pulumi.get(self, "component_statuses")
 
     @property
     @pulumi.getter
-    def country(self) -> Optional[builtins.str]:
+    def name(self) -> Optional[builtins.str]:
         """
-        Country of the address
+        Target name
         """
-        return pulumi.get(self, "country")
+        return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="postalCode")
-    def postal_code(self) -> Optional[builtins.str]:
+    @pulumi.getter
+    def status(self) -> Optional[builtins.str]:
         """
-        Postal or ZIP code of the address
+        Target status
         """
-        return pulumi.get(self, "postal_code")
+        return pulumi.get(self, "status")
 
-    @property
-    @pulumi.getter(name="stateOrProvince")
-    def state_or_province(self) -> Optional[builtins.str]:
+
+@pulumi.output_type
+class TaskOptionResponse(dict):
+    """
+    Task Option Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "errorAction":
+            suggest = "error_action"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TaskOptionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TaskOptionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TaskOptionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 concurrency: Optional[builtins.int] = None,
+                 error_action: Optional['outputs.ErrorActionResponse'] = None):
         """
-        State or province of the address
+        Task Option Properties
+        :param builtins.int concurrency: Parallel worker numbers of the tasks
+        :param 'ErrorActionResponse' error_action: Error action for the tasks
         """
-        return pulumi.get(self, "state_or_province")
+        if concurrency is None:
+            concurrency = 1
+        if concurrency is not None:
+            pulumi.set(__self__, "concurrency", concurrency)
+        if error_action is not None:
+            pulumi.set(__self__, "error_action", error_action)
 
     @property
-    @pulumi.getter(name="streetAddress1")
-    def street_address1(self) -> Optional[builtins.str]:
+    @pulumi.getter
+    def concurrency(self) -> Optional[builtins.int]:
         """
-        First line of the street address
+        Parallel worker numbers of the tasks
         """
-        return pulumi.get(self, "street_address1")
+        return pulumi.get(self, "concurrency")
 
     @property
-    @pulumi.getter(name="streetAddress2")
-    def street_address2(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="errorAction")
+    def error_action(self) -> Optional['outputs.ErrorActionResponse']:
         """
-        Second line of the street address
+        Error action for the tasks
         """
-        return pulumi.get(self, "street_address2")
+        return pulumi.get(self, "error_action")
 
 
 @pulumi.output_type
-class SitePropertiesResponse(dict):
+class TaskSpecResponse(dict):
     """
-    Site properties
+    Task Spec
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "provisioningState":
-            suggest = "provisioning_state"
-        elif key == "addressResourceId":
-            suggest = "address_resource_id"
-        elif key == "displayName":
-            suggest = "display_name"
-        elif key == "siteAddress":
-            suggest = "site_address"
+        if key == "targetId":
+            suggest = "target_id"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SitePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in TaskSpecResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        SitePropertiesResponse.__key_warning(key)
+        TaskSpecResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        SitePropertiesResponse.__key_warning(key)
+        TaskSpecResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 provisioning_state: builtins.str,
-                 address_resource_id: Optional[builtins.str] = None,
-                 description: Optional[builtins.str] = None,
-                 display_name: Optional[builtins.str] = None,
-                 labels: Optional[Mapping[str, builtins.str]] = None,
-                 site_address: Optional['outputs.SiteAddressPropertiesResponse'] = None):
+                 name: builtins.str,
+                 specification: Any,
+                 target_id: Optional[builtins.str] = None):
         """
-        Site properties
-        :param builtins.str provisioning_state: Provisioning state of last operation
-        :param builtins.str address_resource_id: AddressResource ArmId of Site resource
-        :param builtins.str description: Description of Site resource
-        :param builtins.str display_name: displayName of Site resource
-        :param Mapping[str, builtins.str] labels: Key-value pairs for labeling the site resource.
-        :param 'SiteAddressPropertiesResponse' site_address: Physical address of the site
+        Task Spec
+        :param builtins.str name: Name of Task
+        :param Any specification: Task specification
+        :param builtins.str target_id: Target ARM id
         """
-        pulumi.set(__self__, "provisioning_state", provisioning_state)
-        if address_resource_id is not None:
-            pulumi.set(__self__, "address_resource_id", address_resource_id)
-        if description is not None:
-            pulumi.set(__self__, "description", description)
-        if display_name is not None:
-            pulumi.set(__self__, "display_name", display_name)
-        if labels is not None:
-            pulumi.set(__self__, "labels", labels)
-        if site_address is not None:
-            pulumi.set(__self__, "site_address", site_address)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "specification", specification)
+        if target_id is not None:
+            pulumi.set(__self__, "target_id", target_id)
 
     @property
-    @pulumi.getter(name="provisioningState")
-    def provisioning_state(self) -> builtins.str:
+    @pulumi.getter
+    def name(self) -> builtins.str:
         """
-        Provisioning state of last operation
+        Name of Task
         """
-        return pulumi.get(self, "provisioning_state")
+        return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="addressResourceId")
-    def address_resource_id(self) -> Optional[builtins.str]:
+    @pulumi.getter
+    def specification(self) -> Any:
         """
-        AddressResource ArmId of Site resource
+        Task specification
         """
-        return pulumi.get(self, "address_resource_id")
+        return pulumi.get(self, "specification")
 
     @property
-    @pulumi.getter
-    def description(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="targetId")
+    def target_id(self) -> Optional[builtins.str]:
         """
-        Description of Site resource
+        Target ARM id
         """
-        return pulumi.get(self, "description")
+        return pulumi.get(self, "target_id")
 
-    @property
-    @pulumi.getter(name="displayName")
-    def display_name(self) -> Optional[builtins.str]:
+
+@pulumi.output_type
+class WorkflowPropertiesResponse(dict):
+    """
+    Workflow Properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "workflowTemplateId":
+            suggest = "workflow_template_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkflowPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkflowPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkflowPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 workflow_template_id: builtins.str):
         """
-        displayName of Site resource
+        Workflow Properties
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str workflow_template_id: Workflow template Id
         """
-        return pulumi.get(self, "display_name")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "workflow_template_id", workflow_template_id)
 
     @property
-    @pulumi.getter
-    def labels(self) -> Optional[Mapping[str, builtins.str]]:
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
         """
-        Key-value pairs for labeling the site resource.
+        Provisioning state of resource
         """
-        return pulumi.get(self, "labels")
+        return pulumi.get(self, "provisioning_state")
 
     @property
-    @pulumi.getter(name="siteAddress")
-    def site_address(self) -> Optional['outputs.SiteAddressPropertiesResponse']:
+    @pulumi.getter(name="workflowTemplateId")
+    def workflow_template_id(self) -> builtins.str:
         """
-        Physical address of the site
+        Workflow template Id
         """
-        return pulumi.get(self, "site_address")
+        return pulumi.get(self, "workflow_template_id")
 
 
 @pulumi.output_type
-class SystemDataResponse(dict):
+class WorkflowVersionPropertiesResponse(dict):
     """
-    Metadata pertaining to creation and last modification of the resource.
+    Workflow Version Properties
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "createdAt":
-            suggest = "created_at"
-        elif key == "createdBy":
-            suggest = "created_by"
-        elif key == "createdByType":
-            suggest = "created_by_type"
-        elif key == "lastModifiedAt":
-            suggest = "last_modified_at"
-        elif key == "lastModifiedBy":
-            suggest = "last_modified_by"
-        elif key == "lastModifiedByType":
-            suggest = "last_modified_by_type"
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "reviewId":
+            suggest = "review_id"
+        elif key == "stageSpec":
+            suggest = "stage_spec"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SystemDataResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in WorkflowVersionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        SystemDataResponse.__key_warning(key)
+        WorkflowVersionPropertiesResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        SystemDataResponse.__key_warning(key)
+        WorkflowVersionPropertiesResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 created_at: Optional[builtins.str] = None,
-                 created_by: Optional[builtins.str] = None,
-                 created_by_type: Optional[builtins.str] = None,
-                 last_modified_at: Optional[builtins.str] = None,
-                 last_modified_by: Optional[builtins.str] = None,
-                 last_modified_by_type: Optional[builtins.str] = None):
+                 configuration: builtins.str,
+                 provisioning_state: builtins.str,
+                 review_id: builtins.str,
+                 revision: builtins.int,
+                 stage_spec: Sequence['outputs.StageSpecResponse'],
+                 state: builtins.str,
+                 specification: Optional[Any] = None):
         """
-        Metadata pertaining to creation and last modification of the resource.
-        :param builtins.str created_at: The timestamp of resource creation (UTC).
-        :param builtins.str created_by: The identity that created the resource.
-        :param builtins.str created_by_type: The type of identity that created the resource.
-        :param builtins.str last_modified_at: The timestamp of resource last modification (UTC)
-        :param builtins.str last_modified_by: The identity that last modified the resource.
-        :param builtins.str last_modified_by_type: The type of identity that last modified the resource.
+        Workflow Version Properties
+        :param builtins.str configuration: Resolved configuration values
+        :param builtins.str provisioning_state: Provisioning state of resource
+        :param builtins.str review_id: Review id of resolved config for this workflow version
+        :param builtins.int revision: Revision number of resolved config for this workflow version
+        :param Sequence['StageSpecResponse'] stage_spec: A list of stage specs
+        :param builtins.str state: State of workflow version
+        :param Any specification: Execution specification
         """
-        if created_at is not None:
-            pulumi.set(__self__, "created_at", created_at)
-        if created_by is not None:
-            pulumi.set(__self__, "created_by", created_by)
-        if created_by_type is not None:
-            pulumi.set(__self__, "created_by_type", created_by_type)
-        if last_modified_at is not None:
-            pulumi.set(__self__, "last_modified_at", last_modified_at)
-        if last_modified_by is not None:
-            pulumi.set(__self__, "last_modified_by", last_modified_by)
-        if last_modified_by_type is not None:
-            pulumi.set(__self__, "last_modified_by_type", last_modified_by_type)
+        pulumi.set(__self__, "configuration", configuration)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "review_id", review_id)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "stage_spec", stage_spec)
+        pulumi.set(__self__, "state", state)
+        if specification is not None:
+            pulumi.set(__self__, "specification", specification)
 
     @property
-    @pulumi.getter(name="createdAt")
-    def created_at(self) -> Optional[builtins.str]:
+    @pulumi.getter
+    def configuration(self) -> builtins.str:
         """
-        The timestamp of resource creation (UTC).
+        Resolved configuration values
         """
-        return pulumi.get(self, "created_at")
+        return pulumi.get(self, "configuration")
 
     @property
-    @pulumi.getter(name="createdBy")
-    def created_by(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
         """
-        The identity that created the resource.
+        Provisioning state of resource
         """
-        return pulumi.get(self, "created_by")
+        return pulumi.get(self, "provisioning_state")
 
     @property
-    @pulumi.getter(name="createdByType")
-    def created_by_type(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="reviewId")
+    def review_id(self) -> builtins.str:
         """
-        The type of identity that created the resource.
+        Review id of resolved config for this workflow version
         """
-        return pulumi.get(self, "created_by_type")
+        return pulumi.get(self, "review_id")
 
     @property
-    @pulumi.getter(name="lastModifiedAt")
-    def last_modified_at(self) -> Optional[builtins.str]:
+    @pulumi.getter
+    def revision(self) -> builtins.int:
         """
-        The timestamp of resource last modification (UTC)
+        Revision number of resolved config for this workflow version
         """
-        return pulumi.get(self, "last_modified_at")
+        return pulumi.get(self, "revision")
 
     @property
-    @pulumi.getter(name="lastModifiedBy")
-    def last_modified_by(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="stageSpec")
+    def stage_spec(self) -> Sequence['outputs.StageSpecResponse']:
         """
-        The identity that last modified the resource.
+        A list of stage specs
         """
-        return pulumi.get(self, "last_modified_by")
+        return pulumi.get(self, "stage_spec")
 
     @property
-    @pulumi.getter(name="lastModifiedByType")
-    def last_modified_by_type(self) -> Optional[builtins.str]:
+    @pulumi.getter
+    def state(self) -> builtins.str:
         """
-        The type of identity that last modified the resource.
+        State of workflow version
         """
-        return pulumi.get(self, "last_modified_by_type")
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Optional[Any]:
+        """
+        Execution specification
+        """
+        return pulumi.get(self, "specification")