pulumi-azure-native 3.6.0a1751063629__py3-none-any.whl → 3.6.0a1754062012__py3-none-any.whl

pulumi_azure_native/edge/_inputs.py

@@ -14,265 +14,1617 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from ._enums import *
 
 __all__ = [
+    'AzureResourceManagerCommonTypesExtendedLocationArgs',
+    'AzureResourceManagerCommonTypesExtendedLocationArgsDict',
+    'CapabilityArgs',
+    'CapabilityArgsDict',
+    'ConfigTemplatePropertiesArgs',
+    'ConfigTemplatePropertiesArgsDict',
+    'ConfigurationReferencePropertiesArgs',
+    'ConfigurationReferencePropertiesArgsDict',
+    'ContextPropertiesArgs',
+    'ContextPropertiesArgsDict',
+    'DynamicConfigurationPropertiesArgs',
+    'DynamicConfigurationPropertiesArgsDict',
+    'DynamicConfigurationVersionPropertiesArgs',
+    'DynamicConfigurationVersionPropertiesArgsDict',
+    'ErrorActionArgs',
+    'ErrorActionArgsDict',
+    'ExecutionPropertiesArgs',
+    'ExecutionPropertiesArgsDict',
+    'HierarchyArgs',
+    'HierarchyArgsDict',
+    'InstancePropertiesArgs',
+    'InstancePropertiesArgsDict',
+    'ReconciliationPolicyPropertiesArgs',
+    'ReconciliationPolicyPropertiesArgsDict',
+    'SchemaVersionPropertiesArgs',
+    'SchemaVersionPropertiesArgsDict',
     'SiteAddressPropertiesArgs',
     'SiteAddressPropertiesArgsDict',
     'SitePropertiesArgs',
     'SitePropertiesArgsDict',
+    'SiteReferencePropertiesArgs',
+    'SiteReferencePropertiesArgsDict',
+    'SolutionTemplatePropertiesArgs',
+    'SolutionTemplatePropertiesArgsDict',
+    'SolutionVersionPropertiesArgs',
+    'SolutionVersionPropertiesArgsDict',
+    'StageSpecArgs',
+    'StageSpecArgsDict',
+    'TargetPropertiesArgs',
+    'TargetPropertiesArgsDict',
+    'TaskOptionArgs',
+    'TaskOptionArgsDict',
+    'TaskSpecArgs',
+    'TaskSpecArgsDict',
+    'WorkflowVersionPropertiesArgs',
+    'WorkflowVersionPropertiesArgsDict',
 ]
 
 MYPY = False
 
+if not MYPY:
+    class AzureResourceManagerCommonTypesExtendedLocationArgsDict(TypedDict):
+        """
+        The complex type of the extended location.
+        """
+        name: pulumi.Input[builtins.str]
+        """
+        The name of the extended location.
+        """
+        type: pulumi.Input[Union[builtins.str, 'ExtendedLocationType']]
+        """
+        The type of the extended location.
+        """
+elif False:
+    AzureResourceManagerCommonTypesExtendedLocationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AzureResourceManagerCommonTypesExtendedLocationArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[builtins.str],
+                 type: pulumi.Input[Union[builtins.str, 'ExtendedLocationType']]):
+        """
+        The complex type of the extended location.
+        :param pulumi.Input[builtins.str] name: The name of the extended location.
+        :param pulumi.Input[Union[builtins.str, 'ExtendedLocationType']] type: The type of the extended location.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[builtins.str]:
+        """
+        The name of the extended location.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[Union[builtins.str, 'ExtendedLocationType']]:
+        """
+        The type of the extended location.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[Union[builtins.str, 'ExtendedLocationType']]):
+        pulumi.set(self, "type", value)
+
+
+if not MYPY:
+    class CapabilityArgsDict(TypedDict):
+        """
+        Capability, to match in Solution Templates & Targets
+        """
+        description: pulumi.Input[builtins.str]
+        """
+        Description of Capability
+        """
+        name: pulumi.Input[builtins.str]
+        """
+        Name of Capability
+        """
+        state: NotRequired[pulumi.Input[Union[builtins.str, 'ResourceState']]]
+        """
+        State of resource
+        """
+elif False:
+    CapabilityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CapabilityArgs:
+    def __init__(__self__, *,
+                 description: pulumi.Input[builtins.str],
+                 name: pulumi.Input[builtins.str],
+                 state: Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]] = None):
+        """
+        Capability, to match in Solution Templates & Targets
+        :param pulumi.Input[builtins.str] description: Description of Capability
+        :param pulumi.Input[builtins.str] name: Name of Capability
+        :param pulumi.Input[Union[builtins.str, 'ResourceState']] 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) -> pulumi.Input[builtins.str]:
+        """
+        Description of Capability
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[builtins.str]:
+        """
+        Name of Capability
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]]:
+        """
+        State of resource
+        """
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]]):
+        pulumi.set(self, "state", value)
+
+
+if not MYPY:
+    class ConfigTemplatePropertiesArgsDict(TypedDict):
+        """
+        Config Template Properties
+        """
+        description: pulumi.Input[builtins.str]
+        """
+        Description of config template
+        """
+elif False:
+    ConfigTemplatePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConfigTemplatePropertiesArgs:
+    def __init__(__self__, *,
+                 description: pulumi.Input[builtins.str]):
+        """
+        Config Template Properties
+        :param pulumi.Input[builtins.str] description: Description of config template
+        """
+        pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def description(self) -> pulumi.Input[builtins.str]:
+        """
+        Description of config template
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class ConfigurationReferencePropertiesArgsDict(TypedDict):
+        """
+        Properties for ConfigurationReference Resource
+        """
+        configuration_resource_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        ArmId of Configuration resource
+        """
+elif False:
+    ConfigurationReferencePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConfigurationReferencePropertiesArgs:
+    def __init__(__self__, *,
+                 configuration_resource_id: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        Properties for ConfigurationReference Resource
+        :param pulumi.Input[builtins.str] configuration_resource_id: ArmId of Configuration resource
+        """
+        if configuration_resource_id is not None:
+            pulumi.set(__self__, "configuration_resource_id", configuration_resource_id)
+
+    @property
+    @pulumi.getter(name="configurationResourceId")
+    def configuration_resource_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        ArmId of Configuration resource
+        """
+        return pulumi.get(self, "configuration_resource_id")
+
+    @configuration_resource_id.setter
+    def configuration_resource_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "configuration_resource_id", value)
+
+
+if not MYPY:
+    class ContextPropertiesArgsDict(TypedDict):
+        """
+        Context Properties
+        """
+        capabilities: pulumi.Input[Sequence[pulumi.Input['CapabilityArgsDict']]]
+        """
+        List of Capabilities
+        """
+        hierarchies: pulumi.Input[Sequence[pulumi.Input['HierarchyArgsDict']]]
+        """
+        List of Hierarchies
+        """
+elif False:
+    ContextPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ContextPropertiesArgs:
+    def __init__(__self__, *,
+                 capabilities: pulumi.Input[Sequence[pulumi.Input['CapabilityArgs']]],
+                 hierarchies: pulumi.Input[Sequence[pulumi.Input['HierarchyArgs']]]):
+        """
+        Context Properties
+        :param pulumi.Input[Sequence[pulumi.Input['CapabilityArgs']]] capabilities: List of Capabilities
+        :param pulumi.Input[Sequence[pulumi.Input['HierarchyArgs']]] hierarchies: List of Hierarchies
+        """
+        pulumi.set(__self__, "capabilities", capabilities)
+        pulumi.set(__self__, "hierarchies", hierarchies)
+
+    @property
+    @pulumi.getter
+    def capabilities(self) -> pulumi.Input[Sequence[pulumi.Input['CapabilityArgs']]]:
+        """
+        List of Capabilities
+        """
+        return pulumi.get(self, "capabilities")
+
+    @capabilities.setter
+    def capabilities(self, value: pulumi.Input[Sequence[pulumi.Input['CapabilityArgs']]]):
+        pulumi.set(self, "capabilities", value)
+
+    @property
+    @pulumi.getter
+    def hierarchies(self) -> pulumi.Input[Sequence[pulumi.Input['HierarchyArgs']]]:
+        """
+        List of Hierarchies
+        """
+        return pulumi.get(self, "hierarchies")
+
+    @hierarchies.setter
+    def hierarchies(self, value: pulumi.Input[Sequence[pulumi.Input['HierarchyArgs']]]):
+        pulumi.set(self, "hierarchies", value)
+
+
+if not MYPY:
+    class DynamicConfigurationPropertiesArgsDict(TypedDict):
+        """
+        Dynamic Configuration Properties
+        """
+        current_version: pulumi.Input[builtins.str]
+        """
+        Current Version of dynamic configuration
+        """
+elif False:
+    DynamicConfigurationPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DynamicConfigurationPropertiesArgs:
+    def __init__(__self__, *,
+                 current_version: pulumi.Input[builtins.str]):
+        """
+        Dynamic Configuration Properties
+        :param pulumi.Input[builtins.str] current_version: Current Version of dynamic configuration
+        """
+        pulumi.set(__self__, "current_version", current_version)
+
+    @property
+    @pulumi.getter(name="currentVersion")
+    def current_version(self) -> pulumi.Input[builtins.str]:
+        """
+        Current Version of dynamic configuration
+        """
+        return pulumi.get(self, "current_version")
+
+    @current_version.setter
+    def current_version(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "current_version", value)
+
+
+if not MYPY:
+    class DynamicConfigurationVersionPropertiesArgsDict(TypedDict):
+        """
+        Dynamic Configuration Properties
+        """
+        values: pulumi.Input[builtins.str]
+        """
+        Values of configuration version
+        """
+elif False:
+    DynamicConfigurationVersionPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DynamicConfigurationVersionPropertiesArgs:
+    def __init__(__self__, *,
+                 values: pulumi.Input[builtins.str]):
+        """
+        Dynamic Configuration Properties
+        :param pulumi.Input[builtins.str] values: Values of configuration version
+        """
+        pulumi.set(__self__, "values", values)
+
+    @property
+    @pulumi.getter
+    def values(self) -> pulumi.Input[builtins.str]:
+        """
+        Values of configuration version
+        """
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "values", value)
+
+
+if not MYPY:
+    class ErrorActionArgsDict(TypedDict):
+        """
+        Error Action Properties
+        """
+        max_tolerated_failures: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Max tolerated failures
+        """
+        mode: NotRequired[pulumi.Input[Union[builtins.str, 'ErrorActionMode']]]
+        """
+        Error action mode
+        """
+elif False:
+    ErrorActionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ErrorActionArgs:
+    def __init__(__self__, *,
+                 max_tolerated_failures: Optional[pulumi.Input[builtins.int]] = None,
+                 mode: Optional[pulumi.Input[Union[builtins.str, 'ErrorActionMode']]] = None):
+        """
+        Error Action Properties
+        :param pulumi.Input[builtins.int] max_tolerated_failures: Max tolerated failures
+        :param pulumi.Input[Union[builtins.str, 'ErrorActionMode']] 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[pulumi.Input[builtins.int]]:
+        """
+        Max tolerated failures
+        """
+        return pulumi.get(self, "max_tolerated_failures")
+
+    @max_tolerated_failures.setter
+    def max_tolerated_failures(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "max_tolerated_failures", value)
+
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[pulumi.Input[Union[builtins.str, 'ErrorActionMode']]]:
+        """
+        Error action mode
+        """
+        return pulumi.get(self, "mode")
+
+    @mode.setter
+    def mode(self, value: Optional[pulumi.Input[Union[builtins.str, 'ErrorActionMode']]]):
+        pulumi.set(self, "mode", value)
+
+
+if not MYPY:
+    class ExecutionPropertiesArgsDict(TypedDict):
+        """
+        Execution Properties
+        """
+        workflow_version_id: pulumi.Input[builtins.str]
+        """
+        Workflow version of execution
+        """
+        specification: NotRequired[Any]
+        """
+        Execution specification
+        """
+elif False:
+    ExecutionPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExecutionPropertiesArgs:
+    def __init__(__self__, *,
+                 workflow_version_id: pulumi.Input[builtins.str],
+                 specification: Optional[Any] = None):
+        """
+        Execution Properties
+        :param pulumi.Input[builtins.str] workflow_version_id: Workflow version of execution
+        :param Any specification: Execution specification
+        """
+        pulumi.set(__self__, "workflow_version_id", workflow_version_id)
+        if specification is not None:
+            pulumi.set(__self__, "specification", specification)
+
+    @property
+    @pulumi.getter(name="workflowVersionId")
+    def workflow_version_id(self) -> pulumi.Input[builtins.str]:
+        """
+        Workflow version of execution
+        """
+        return pulumi.get(self, "workflow_version_id")
+
+    @workflow_version_id.setter
+    def workflow_version_id(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "workflow_version_id", value)
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Optional[Any]:
+        """
+        Execution specification
+        """
+        return pulumi.get(self, "specification")
+
+    @specification.setter
+    def specification(self, value: Optional[Any]):
+        pulumi.set(self, "specification", value)
+
+
+if not MYPY:
+    class HierarchyArgsDict(TypedDict):
+        """
+        Hierarchy, to tag Sites / Hierarchy Provider nodes with what they represent
+        """
+        description: pulumi.Input[builtins.str]
+        """
+        Description of Hierarchy
+        """
+        name: pulumi.Input[builtins.str]
+        """
+        Name of Hierarchy
+        """
+elif False:
+    HierarchyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class HierarchyArgs:
+    def __init__(__self__, *,
+                 description: pulumi.Input[builtins.str],
+                 name: pulumi.Input[builtins.str]):
+        """
+        Hierarchy, to tag Sites / Hierarchy Provider nodes with what they represent
+        :param pulumi.Input[builtins.str] description: Description of Hierarchy
+        :param pulumi.Input[builtins.str] name: Name of Hierarchy
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def description(self) -> pulumi.Input[builtins.str]:
+        """
+        Description of Hierarchy
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[builtins.str]:
+        """
+        Name of Hierarchy
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
+
+
+if not MYPY:
+    class InstancePropertiesArgsDict(TypedDict):
+        """
+        Instance Properties
+        """
+        solution_version_id: pulumi.Input[builtins.str]
+        """
+        Solution version of instance
+        """
+        target_id: pulumi.Input[builtins.str]
+        """
+        Target of instance
+        """
+        active_state: NotRequired[pulumi.Input[Union[builtins.str, 'ActiveState']]]
+        """
+        State of instance
+        """
+        reconciliation_policy: NotRequired[pulumi.Input['ReconciliationPolicyPropertiesArgsDict']]
+        """
+        Reconciliation policy of instance
+        """
+        solution_scope: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Scope of instance
+        """
+elif False:
+    InstancePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstancePropertiesArgs:
+    def __init__(__self__, *,
+                 solution_version_id: pulumi.Input[builtins.str],
+                 target_id: pulumi.Input[builtins.str],
+                 active_state: Optional[pulumi.Input[Union[builtins.str, 'ActiveState']]] = None,
+                 reconciliation_policy: Optional[pulumi.Input['ReconciliationPolicyPropertiesArgs']] = None,
+                 solution_scope: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        Instance Properties
+        :param pulumi.Input[builtins.str] solution_version_id: Solution version of instance
+        :param pulumi.Input[builtins.str] target_id: Target of instance
+        :param pulumi.Input[Union[builtins.str, 'ActiveState']] active_state: State of instance
+        :param pulumi.Input['ReconciliationPolicyPropertiesArgs'] reconciliation_policy: Reconciliation policy of instance
+        :param pulumi.Input[builtins.str] solution_scope: Scope of instance
+        """
+        pulumi.set(__self__, "solution_version_id", solution_version_id)
+        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="solutionVersionId")
+    def solution_version_id(self) -> pulumi.Input[builtins.str]:
+        """
+        Solution version of instance
+        """
+        return pulumi.get(self, "solution_version_id")
+
+    @solution_version_id.setter
+    def solution_version_id(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "solution_version_id", value)
+
+    @property
+    @pulumi.getter(name="targetId")
+    def target_id(self) -> pulumi.Input[builtins.str]:
+        """
+        Target of instance
+        """
+        return pulumi.get(self, "target_id")
+
+    @target_id.setter
+    def target_id(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "target_id", value)
+
+    @property
+    @pulumi.getter(name="activeState")
+    def active_state(self) -> Optional[pulumi.Input[Union[builtins.str, 'ActiveState']]]:
+        """
+        State of instance
+        """
+        return pulumi.get(self, "active_state")
+
+    @active_state.setter
+    def active_state(self, value: Optional[pulumi.Input[Union[builtins.str, 'ActiveState']]]):
+        pulumi.set(self, "active_state", value)
+
+    @property
+    @pulumi.getter(name="reconciliationPolicy")
+    def reconciliation_policy(self) -> Optional[pulumi.Input['ReconciliationPolicyPropertiesArgs']]:
+        """
+        Reconciliation policy of instance
+        """
+        return pulumi.get(self, "reconciliation_policy")
+
+    @reconciliation_policy.setter
+    def reconciliation_policy(self, value: Optional[pulumi.Input['ReconciliationPolicyPropertiesArgs']]):
+        pulumi.set(self, "reconciliation_policy", value)
+
+    @property
+    @pulumi.getter(name="solutionScope")
+    def solution_scope(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Scope of instance
+        """
+        return pulumi.get(self, "solution_scope")
+
+    @solution_scope.setter
+    def solution_scope(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "solution_scope", value)
+
+
+if not MYPY:
+    class ReconciliationPolicyPropertiesArgsDict(TypedDict):
+        """
+        Defines a ReconciliationPolicy
+        """
+        interval: pulumi.Input[builtins.str]
+        """
+        Policy interval
+        """
+        state: pulumi.Input[Union[builtins.str, 'ReconciliationState']]
+        """
+        The state of the ReconciliationPolicy
+        """
+elif False:
+    ReconciliationPolicyPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReconciliationPolicyPropertiesArgs:
+    def __init__(__self__, *,
+                 interval: pulumi.Input[builtins.str],
+                 state: pulumi.Input[Union[builtins.str, 'ReconciliationState']]):
+        """
+        Defines a ReconciliationPolicy
+        :param pulumi.Input[builtins.str] interval: Policy interval
+        :param pulumi.Input[Union[builtins.str, 'ReconciliationState']] state: The state of the ReconciliationPolicy
+        """
+        pulumi.set(__self__, "interval", interval)
+        pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def interval(self) -> pulumi.Input[builtins.str]:
+        """
+        Policy interval
+        """
+        return pulumi.get(self, "interval")
+
+    @interval.setter
+    def interval(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "interval", value)
+
+    @property
+    @pulumi.getter
+    def state(self) -> pulumi.Input[Union[builtins.str, 'ReconciliationState']]:
+        """
+        The state of the ReconciliationPolicy
+        """
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: pulumi.Input[Union[builtins.str, 'ReconciliationState']]):
+        pulumi.set(self, "state", value)
+
+
+if not MYPY:
+    class SchemaVersionPropertiesArgsDict(TypedDict):
+        """
+        Schema Version Properties
+        """
+        value: pulumi.Input[builtins.str]
+        """
+        Value of schema version
+        """
+elif False:
+    SchemaVersionPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SchemaVersionPropertiesArgs:
+    def __init__(__self__, *,
+                 value: pulumi.Input[builtins.str]):
+        """
+        Schema Version Properties
+        :param pulumi.Input[builtins.str] value: Value of schema version
+        """
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> pulumi.Input[builtins.str]:
+        """
+        Value of schema version
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class SiteAddressPropertiesArgsDict(TypedDict):
         """
-        Site address properties
+        Site address properties
+        """
+        city: NotRequired[pulumi.Input[builtins.str]]
+        """
+        City of the address
+        """
+        country: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Country of the address
+        """
+        postal_code: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Postal or ZIP code of the address
+        """
+        state_or_province: NotRequired[pulumi.Input[builtins.str]]
+        """
+        State or province of the address
+        """
+        street_address1: NotRequired[pulumi.Input[builtins.str]]
+        """
+        First line of the street address
+        """
+        street_address2: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Second line of the street address
+        """
+elif False:
+    SiteAddressPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SiteAddressPropertiesArgs:
+    def __init__(__self__, *,
+                 city: Optional[pulumi.Input[builtins.str]] = None,
+                 country: Optional[pulumi.Input[builtins.str]] = None,
+                 postal_code: Optional[pulumi.Input[builtins.str]] = None,
+                 state_or_province: Optional[pulumi.Input[builtins.str]] = None,
+                 street_address1: Optional[pulumi.Input[builtins.str]] = None,
+                 street_address2: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        Site address properties
+        :param pulumi.Input[builtins.str] city: City of the address
+        :param pulumi.Input[builtins.str] country: Country of the address
+        :param pulumi.Input[builtins.str] postal_code: Postal or ZIP code of the address
+        :param pulumi.Input[builtins.str] state_or_province: State or province of the address
+        :param pulumi.Input[builtins.str] street_address1: First line of the street address
+        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
+        """
+        City of the address
+        """
+        return pulumi.get(self, "city")
+
+    @city.setter
+    def city(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "city", value)
+
+    @property
+    @pulumi.getter
+    def country(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Country of the address
+        """
+        return pulumi.get(self, "country")
+
+    @country.setter
+    def country(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "country", value)
+
+    @property
+    @pulumi.getter(name="postalCode")
+    def postal_code(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Postal or ZIP code of the address
+        """
+        return pulumi.get(self, "postal_code")
+
+    @postal_code.setter
+    def postal_code(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "postal_code", value)
+
+    @property
+    @pulumi.getter(name="stateOrProvince")
+    def state_or_province(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        State or province of the address
+        """
+        return pulumi.get(self, "state_or_province")
+
+    @state_or_province.setter
+    def state_or_province(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "state_or_province", value)
+
+    @property
+    @pulumi.getter(name="streetAddress1")
+    def street_address1(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        First line of the street address
+        """
+        return pulumi.get(self, "street_address1")
+
+    @street_address1.setter
+    def street_address1(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "street_address1", value)
+
+    @property
+    @pulumi.getter(name="streetAddress2")
+    def street_address2(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Second line of the street address
+        """
+        return pulumi.get(self, "street_address2")
+
+    @street_address2.setter
+    def street_address2(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "street_address2", value)
+
+
+if not MYPY:
+    class SitePropertiesArgsDict(TypedDict):
+        """
+        Site properties
+        """
+        address_resource_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        AddressResource ArmId of Site resource
+        """
+        description: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Description of Site resource
+        """
+        display_name: NotRequired[pulumi.Input[builtins.str]]
+        """
+        displayName of Site resource
+        """
+        labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
+        """
+        Key-value pairs for labeling the site resource.
+        """
+        site_address: NotRequired[pulumi.Input['SiteAddressPropertiesArgsDict']]
+        """
+        Physical address of the site
+        """
+elif False:
+    SitePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SitePropertiesArgs:
+    def __init__(__self__, *,
+                 address_resource_id: Optional[pulumi.Input[builtins.str]] = None,
+                 description: Optional[pulumi.Input[builtins.str]] = None,
+                 display_name: Optional[pulumi.Input[builtins.str]] = None,
+                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
+                 site_address: Optional[pulumi.Input['SiteAddressPropertiesArgs']] = None):
+        """
+        Site properties
+        :param pulumi.Input[builtins.str] address_resource_id: AddressResource ArmId of Site resource
+        :param pulumi.Input[builtins.str] description: Description of Site resource
+        :param pulumi.Input[builtins.str] display_name: displayName of Site resource
+        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Key-value pairs for labeling the site resource.
+        :param pulumi.Input['SiteAddressPropertiesArgs'] site_address: Physical address of the site
+        """
+        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="addressResourceId")
+    def address_resource_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        AddressResource ArmId of Site resource
+        """
+        return pulumi.get(self, "address_resource_id")
+
+    @address_resource_id.setter
+    def address_resource_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "address_resource_id", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Description of Site resource
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        displayName of Site resource
+        """
+        return pulumi.get(self, "display_name")
+
+    @display_name.setter
+    def display_name(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "display_name", value)
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
+        """
+        Key-value pairs for labeling the site resource.
+        """
+        return pulumi.get(self, "labels")
+
+    @labels.setter
+    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "labels", value)
+
+    @property
+    @pulumi.getter(name="siteAddress")
+    def site_address(self) -> Optional[pulumi.Input['SiteAddressPropertiesArgs']]:
+        """
+        Physical address of the site
+        """
+        return pulumi.get(self, "site_address")
+
+    @site_address.setter
+    def site_address(self, value: Optional[pulumi.Input['SiteAddressPropertiesArgs']]):
+        pulumi.set(self, "site_address", value)
+
+
+if not MYPY:
+    class SiteReferencePropertiesArgsDict(TypedDict):
+        """
+        Site Reference Properties
+        """
+        site_id: pulumi.Input[builtins.str]
+        """
+        Azure Resource ID for Site
+        """
+elif False:
+    SiteReferencePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SiteReferencePropertiesArgs:
+    def __init__(__self__, *,
+                 site_id: pulumi.Input[builtins.str]):
+        """
+        Site Reference Properties
+        :param pulumi.Input[builtins.str] site_id: Azure Resource ID for Site
+        """
+        pulumi.set(__self__, "site_id", site_id)
+
+    @property
+    @pulumi.getter(name="siteId")
+    def site_id(self) -> pulumi.Input[builtins.str]:
+        """
+        Azure Resource ID for Site
+        """
+        return pulumi.get(self, "site_id")
+
+    @site_id.setter
+    def site_id(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "site_id", value)
+
+
+if not MYPY:
+    class SolutionTemplatePropertiesArgsDict(TypedDict):
+        """
+        Solution Template Properties
+        """
+        capabilities: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
+        """
+        List of capabilities
+        """
+        description: pulumi.Input[builtins.str]
+        """
+        Description of Solution template
+        """
+        enable_external_validation: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Flag to enable external validation
+        """
+        state: NotRequired[pulumi.Input[Union[builtins.str, 'ResourceState']]]
+        """
+        State of resource
+        """
+elif False:
+    SolutionTemplatePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SolutionTemplatePropertiesArgs:
+    def __init__(__self__, *,
+                 capabilities: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
+                 description: pulumi.Input[builtins.str],
+                 enable_external_validation: Optional[pulumi.Input[builtins.bool]] = None,
+                 state: Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]] = None):
+        """
+        Solution Template Properties
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] capabilities: List of capabilities
+        :param pulumi.Input[builtins.str] description: Description of Solution template
+        :param pulumi.Input[builtins.bool] enable_external_validation: Flag to enable external validation
+        :param pulumi.Input[Union[builtins.str, 'ResourceState']] state: State of resource
+        """
+        pulumi.set(__self__, "capabilities", capabilities)
+        pulumi.set(__self__, "description", description)
+        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) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
+        """
+        List of capabilities
+        """
+        return pulumi.get(self, "capabilities")
+
+    @capabilities.setter
+    def capabilities(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
+        pulumi.set(self, "capabilities", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> pulumi.Input[builtins.str]:
+        """
+        Description of Solution template
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter(name="enableExternalValidation")
+    def enable_external_validation(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Flag to enable external validation
+        """
+        return pulumi.get(self, "enable_external_validation")
+
+    @enable_external_validation.setter
+    def enable_external_validation(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "enable_external_validation", value)
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]]:
+        """
+        State of resource
+        """
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]]):
+        pulumi.set(self, "state", value)
+
+
+if not MYPY:
+    class SolutionVersionPropertiesArgsDict(TypedDict):
+        """
+        Solution Version Properties
+        """
+        specification: Any
+        """
+        App components spec
+        """
+elif False:
+    SolutionVersionPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SolutionVersionPropertiesArgs:
+    def __init__(__self__, *,
+                 specification: Any):
+        """
+        Solution Version Properties
+        :param Any specification: App components spec
+        """
+        pulumi.set(__self__, "specification", specification)
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Any:
+        """
+        App components spec
+        """
+        return pulumi.get(self, "specification")
+
+    @specification.setter
+    def specification(self, value: Any):
+        pulumi.set(self, "specification", value)
+
+
+if not MYPY:
+    class StageSpecArgsDict(TypedDict):
+        """
+        Stage Properties
         """
-        city: NotRequired[pulumi.Input[builtins.str]]
+        name: pulumi.Input[builtins.str]
         """
-        City of the address
+        Name of Stage
         """
-        country: NotRequired[pulumi.Input[builtins.str]]
+        specification: NotRequired[Any]
         """
-        Country of the address
+        Stage specification
         """
-        postal_code: NotRequired[pulumi.Input[builtins.str]]
+        task_option: NotRequired[pulumi.Input['TaskOptionArgsDict']]
         """
-        Postal or ZIP code of the address
+        Task option for the stage
         """
-        state_or_province: NotRequired[pulumi.Input[builtins.str]]
+        tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskSpecArgsDict']]]]
         """
-        State or province of the address
+        List of tasks in the stage
         """
-        street_address1: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    StageSpecArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class StageSpecArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[builtins.str],
+                 specification: Optional[Any] = None,
+                 task_option: Optional[pulumi.Input['TaskOptionArgs']] = None,
+                 tasks: Optional[pulumi.Input[Sequence[pulumi.Input['TaskSpecArgs']]]] = None):
         """
-        First line of the street address
+        Stage Properties
+        :param pulumi.Input[builtins.str] name: Name of Stage
+        :param Any specification: Stage specification
+        :param pulumi.Input['TaskOptionArgs'] task_option: Task option for the stage
+        :param pulumi.Input[Sequence[pulumi.Input['TaskSpecArgs']]] tasks: List of tasks in the stage
         """
-        street_address2: NotRequired[pulumi.Input[builtins.str]]
+        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) -> pulumi.Input[builtins.str]:
         """
-        Second line of the street address
+        Name of Stage
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def specification(self) -> Optional[Any]:
+        """
+        Stage specification
+        """
+        return pulumi.get(self, "specification")
+
+    @specification.setter
+    def specification(self, value: Optional[Any]):
+        pulumi.set(self, "specification", value)
+
+    @property
+    @pulumi.getter(name="taskOption")
+    def task_option(self) -> Optional[pulumi.Input['TaskOptionArgs']]:
+        """
+        Task option for the stage
+        """
+        return pulumi.get(self, "task_option")
+
+    @task_option.setter
+    def task_option(self, value: Optional[pulumi.Input['TaskOptionArgs']]):
+        pulumi.set(self, "task_option", value)
+
+    @property
+    @pulumi.getter
+    def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskSpecArgs']]]]:
+        """
+        List of tasks in the stage
+        """
+        return pulumi.get(self, "tasks")
+
+    @tasks.setter
+    def tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskSpecArgs']]]]):
+        pulumi.set(self, "tasks", value)
+
+
+if not MYPY:
+    class TargetPropertiesArgsDict(TypedDict):
+        """
+        Target Properties
+        """
+        capabilities: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
+        """
+        List of capabilities
+        """
+        context_id: pulumi.Input[builtins.str]
+        """
+        ArmId of Context
+        """
+        description: pulumi.Input[builtins.str]
+        """
+        Description of target
+        """
+        display_name: pulumi.Input[builtins.str]
+        """
+        Display name of target
+        """
+        hierarchy_level: pulumi.Input[builtins.str]
+        """
+        Hierarchy Level
+        """
+        target_specification: Any
+        """
+        target spec
+        """
+        solution_scope: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Scope of the target resource
+        """
+        state: NotRequired[pulumi.Input[Union[builtins.str, 'ResourceState']]]
+        """
+        State of resource
         """
 elif False:
-    SiteAddressPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+    TargetPropertiesArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class SiteAddressPropertiesArgs:
+class TargetPropertiesArgs:
     def __init__(__self__, *,
-                 city: Optional[pulumi.Input[builtins.str]] = None,
-                 country: Optional[pulumi.Input[builtins.str]] = None,
-                 postal_code: Optional[pulumi.Input[builtins.str]] = None,
-                 state_or_province: Optional[pulumi.Input[builtins.str]] = None,
-                 street_address1: Optional[pulumi.Input[builtins.str]] = None,
-                 street_address2: Optional[pulumi.Input[builtins.str]] = None):
+                 capabilities: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
+                 context_id: pulumi.Input[builtins.str],
+                 description: pulumi.Input[builtins.str],
+                 display_name: pulumi.Input[builtins.str],
+                 hierarchy_level: pulumi.Input[builtins.str],
+                 target_specification: Any,
+                 solution_scope: Optional[pulumi.Input[builtins.str]] = None,
+                 state: Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]] = None):
         """
-        Site address properties
-        :param pulumi.Input[builtins.str] city: City of the address
-        :param pulumi.Input[builtins.str] country: Country of the address
-        :param pulumi.Input[builtins.str] postal_code: Postal or ZIP code of the address
-        :param pulumi.Input[builtins.str] state_or_province: State or province of the address
-        :param pulumi.Input[builtins.str] street_address1: First line of the street address
-        :param pulumi.Input[builtins.str] street_address2: Second line of the street address
+        Target Properties
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] capabilities: List of capabilities
+        :param pulumi.Input[builtins.str] context_id: ArmId of Context
+        :param pulumi.Input[builtins.str] description: Description of target
+        :param pulumi.Input[builtins.str] display_name: Display name of target
+        :param pulumi.Input[builtins.str] hierarchy_level: Hierarchy Level
+        :param Any target_specification: target spec
+        :param pulumi.Input[builtins.str] solution_scope: Scope of the target resource
+        :param pulumi.Input[Union[builtins.str, 'ResourceState']] state: State of resource
         """
-        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)
+        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__, "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 city(self) -> Optional[pulumi.Input[builtins.str]]:
+    def capabilities(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
         """
-        City of the address
+        List of capabilities
         """
-        return pulumi.get(self, "city")
+        return pulumi.get(self, "capabilities")
 
-    @city.setter
-    def city(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "city", value)
+    @capabilities.setter
+    def capabilities(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
+        pulumi.set(self, "capabilities", value)
+
+    @property
+    @pulumi.getter(name="contextId")
+    def context_id(self) -> pulumi.Input[builtins.str]:
+        """
+        ArmId of Context
+        """
+        return pulumi.get(self, "context_id")
+
+    @context_id.setter
+    def context_id(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "context_id", value)
 
     @property
     @pulumi.getter
-    def country(self) -> Optional[pulumi.Input[builtins.str]]:
+    def description(self) -> pulumi.Input[builtins.str]:
         """
-        Country of the address
+        Description of target
         """
-        return pulumi.get(self, "country")
+        return pulumi.get(self, "description")
 
-    @country.setter
-    def country(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "country", value)
+    @description.setter
+    def description(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "description", value)
 
     @property
-    @pulumi.getter(name="postalCode")
-    def postal_code(self) -> Optional[pulumi.Input[builtins.str]]:
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> pulumi.Input[builtins.str]:
         """
-        Postal or ZIP code of the address
+        Display name of target
         """
-        return pulumi.get(self, "postal_code")
+        return pulumi.get(self, "display_name")
 
-    @postal_code.setter
-    def postal_code(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "postal_code", value)
+    @display_name.setter
+    def display_name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "display_name", value)
 
     @property
-    @pulumi.getter(name="stateOrProvince")
-    def state_or_province(self) -> Optional[pulumi.Input[builtins.str]]:
+    @pulumi.getter(name="hierarchyLevel")
+    def hierarchy_level(self) -> pulumi.Input[builtins.str]:
         """
-        State or province of the address
+        Hierarchy Level
         """
-        return pulumi.get(self, "state_or_province")
+        return pulumi.get(self, "hierarchy_level")
 
-    @state_or_province.setter
-    def state_or_province(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "state_or_province", value)
+    @hierarchy_level.setter
+    def hierarchy_level(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "hierarchy_level", value)
 
     @property
-    @pulumi.getter(name="streetAddress1")
-    def street_address1(self) -> Optional[pulumi.Input[builtins.str]]:
+    @pulumi.getter(name="targetSpecification")
+    def target_specification(self) -> Any:
         """
-        First line of the street address
+        target spec
         """
-        return pulumi.get(self, "street_address1")
+        return pulumi.get(self, "target_specification")
 
-    @street_address1.setter
-    def street_address1(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "street_address1", value)
+    @target_specification.setter
+    def target_specification(self, value: Any):
+        pulumi.set(self, "target_specification", value)
 
     @property
-    @pulumi.getter(name="streetAddress2")
-    def street_address2(self) -> Optional[pulumi.Input[builtins.str]]:
+    @pulumi.getter(name="solutionScope")
+    def solution_scope(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        Second line of the street address
+        Scope of the target resource
         """
-        return pulumi.get(self, "street_address2")
+        return pulumi.get(self, "solution_scope")
 
-    @street_address2.setter
-    def street_address2(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "street_address2", value)
+    @solution_scope.setter
+    def solution_scope(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "solution_scope", value)
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]]:
+        """
+        State of resource
+        """
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: Optional[pulumi.Input[Union[builtins.str, 'ResourceState']]]):
+        pulumi.set(self, "state", value)
 
 
 if not MYPY:
-    class SitePropertiesArgsDict(TypedDict):
+    class TaskOptionArgsDict(TypedDict):
         """
-        Site properties
+        Task Option Properties
         """
-        address_resource_id: NotRequired[pulumi.Input[builtins.str]]
+        concurrency: NotRequired[pulumi.Input[builtins.int]]
         """
-        AddressResource ArmId of Site resource
+        Parallel worker numbers of the tasks
         """
-        description: NotRequired[pulumi.Input[builtins.str]]
+        error_action: NotRequired[pulumi.Input['ErrorActionArgsDict']]
         """
-        Description of Site resource
+        Error action for the tasks
         """
-        display_name: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    TaskOptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TaskOptionArgs:
+    def __init__(__self__, *,
+                 concurrency: Optional[pulumi.Input[builtins.int]] = None,
+                 error_action: Optional[pulumi.Input['ErrorActionArgs']] = None):
         """
-        displayName of Site resource
+        Task Option Properties
+        :param pulumi.Input[builtins.int] concurrency: Parallel worker numbers of the tasks
+        :param pulumi.Input['ErrorActionArgs'] error_action: Error action for the tasks
         """
-        labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
+        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
+    def concurrency(self) -> Optional[pulumi.Input[builtins.int]]:
         """
-        Key-value pairs for labeling the site resource.
+        Parallel worker numbers of the tasks
         """
-        site_address: NotRequired[pulumi.Input['SiteAddressPropertiesArgsDict']]
+        return pulumi.get(self, "concurrency")
+
+    @concurrency.setter
+    def concurrency(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "concurrency", value)
+
+    @property
+    @pulumi.getter(name="errorAction")
+    def error_action(self) -> Optional[pulumi.Input['ErrorActionArgs']]:
         """
-        Physical address of the site
+        Error action for the tasks
+        """
+        return pulumi.get(self, "error_action")
+
+    @error_action.setter
+    def error_action(self, value: Optional[pulumi.Input['ErrorActionArgs']]):
+        pulumi.set(self, "error_action", value)
+
+
+if not MYPY:
+    class TaskSpecArgsDict(TypedDict):
+        """
+        Task Spec
+        """
+        name: pulumi.Input[builtins.str]
+        """
+        Name of Task
+        """
+        specification: Any
+        """
+        Task specification
+        """
+        target_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Target ARM id
         """
 elif False:
-    SitePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+    TaskSpecArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class SitePropertiesArgs:
+class TaskSpecArgs:
     def __init__(__self__, *,
-                 address_resource_id: Optional[pulumi.Input[builtins.str]] = None,
-                 description: Optional[pulumi.Input[builtins.str]] = None,
-                 display_name: Optional[pulumi.Input[builtins.str]] = None,
-                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
-                 site_address: Optional[pulumi.Input['SiteAddressPropertiesArgs']] = None):
+                 name: pulumi.Input[builtins.str],
+                 specification: Any,
+                 target_id: Optional[pulumi.Input[builtins.str]] = None):
         """
-        Site properties
-        :param pulumi.Input[builtins.str] address_resource_id: AddressResource ArmId of Site resource
-        :param pulumi.Input[builtins.str] description: Description of Site resource
-        :param pulumi.Input[builtins.str] display_name: displayName of Site resource
-        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Key-value pairs for labeling the site resource.
-        :param pulumi.Input['SiteAddressPropertiesArgs'] site_address: Physical address of the site
+        Task Spec
+        :param pulumi.Input[builtins.str] name: Name of Task
+        :param Any specification: Task specification
+        :param pulumi.Input[builtins.str] target_id: Target ARM id
         """
-        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="addressResourceId")
-    def address_resource_id(self) -> Optional[pulumi.Input[builtins.str]]:
+    @pulumi.getter
+    def name(self) -> pulumi.Input[builtins.str]:
         """
-        AddressResource ArmId of Site resource
+        Name of Task
         """
-        return pulumi.get(self, "address_resource_id")
+        return pulumi.get(self, "name")
 
-    @address_resource_id.setter
-    def address_resource_id(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "address_resource_id", value)
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
 
     @property
     @pulumi.getter
-    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+    def specification(self) -> Any:
         """
-        Description of Site resource
+        Task specification
         """
-        return pulumi.get(self, "description")
+        return pulumi.get(self, "specification")
 
-    @description.setter
-    def description(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "description", value)
+    @specification.setter
+    def specification(self, value: Any):
+        pulumi.set(self, "specification", value)
 
     @property
-    @pulumi.getter(name="displayName")
-    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
+    @pulumi.getter(name="targetId")
+    def target_id(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        displayName of Site resource
+        Target ARM id
         """
-        return pulumi.get(self, "display_name")
+        return pulumi.get(self, "target_id")
 
-    @display_name.setter
-    def display_name(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "display_name", value)
+    @target_id.setter
+    def target_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "target_id", value)
+
+
+if not MYPY:
+    class WorkflowVersionPropertiesArgsDict(TypedDict):
+        """
+        Workflow Version Properties
+        """
+        stage_spec: pulumi.Input[Sequence[pulumi.Input['StageSpecArgsDict']]]
+        """
+        A list of stage specs
+        """
+        specification: NotRequired[Any]
+        """
+        Execution specification
+        """
+elif False:
+    WorkflowVersionPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class WorkflowVersionPropertiesArgs:
+    def __init__(__self__, *,
+                 stage_spec: pulumi.Input[Sequence[pulumi.Input['StageSpecArgs']]],
+                 specification: Optional[Any] = None):
+        """
+        Workflow Version Properties
+        :param pulumi.Input[Sequence[pulumi.Input['StageSpecArgs']]] stage_spec: A list of stage specs
+        :param Any specification: Execution specification
+        """
+        pulumi.set(__self__, "stage_spec", stage_spec)
+        if specification is not None:
+            pulumi.set(__self__, "specification", specification)
 
     @property
-    @pulumi.getter
-    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
+    @pulumi.getter(name="stageSpec")
+    def stage_spec(self) -> pulumi.Input[Sequence[pulumi.Input['StageSpecArgs']]]:
         """
-        Key-value pairs for labeling the site resource.
+        A list of stage specs
         """
-        return pulumi.get(self, "labels")
+        return pulumi.get(self, "stage_spec")
 
-    @labels.setter
-    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
-        pulumi.set(self, "labels", value)
+    @stage_spec.setter
+    def stage_spec(self, value: pulumi.Input[Sequence[pulumi.Input['StageSpecArgs']]]):
+        pulumi.set(self, "stage_spec", value)
 
     @property
-    @pulumi.getter(name="siteAddress")
-    def site_address(self) -> Optional[pulumi.Input['SiteAddressPropertiesArgs']]:
+    @pulumi.getter
+    def specification(self) -> Optional[Any]:
         """
-        Physical address of the site
+        Execution specification
         """
-        return pulumi.get(self, "site_address")
+        return pulumi.get(self, "specification")
 
-    @site_address.setter
-    def site_address(self, value: Optional[pulumi.Input['SiteAddressPropertiesArgs']]):
-        pulumi.set(self, "site_address", value)
+    @specification.setter
+    def specification(self, value: Optional[Any]):
+        pulumi.set(self, "specification", value)