two version of R2R are hereHEADmaster

44 files changed, 28210 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/__init__.py
new file mode 100644
index 00000000..29a4fcd3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/__init__.py
@@ -0,0 +1,5 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_appinsights_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_appinsights_utils.py
new file mode 100644
index 00000000..579ece7a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_appinsights_utils.py
@@ -0,0 +1,16 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+
+module_logger = logging.getLogger(__name__)
+
+
+def get_log_analytics_arm_id(subscription_id: str, resource_group_name: str, log_analytics_name: str) -> str:
+    return (
+        f"/subscriptions/{subscription_id}/"
+        f"resourceGroups/{resource_group_name}/"
+        "providers/Microsoft.OperationalInsights/workspaces/"
+        f"{log_analytics_name}"
+    )
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_arm_id_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_arm_id_utils.py
new file mode 100644
index 00000000..83545b9d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_arm_id_utils.py
@@ -0,0 +1,506 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+import re
+from typing import Any, Optional, Tuple, Union
+
+from azure.ai.ml._scope_dependent_operations import OperationScope
+from azure.ai.ml.constants._common import (
+    ARM_ID_PREFIX,
+    ASSET_ID_URI_REGEX_FORMAT,
+    AZUREML_RESOURCE_PROVIDER,
+    DATA_ARM_TYPE,
+    DATASTORE_RESOURCE_ID,
+    DATASTORE_SHORT_URI,
+    LEVEL_ONE_NAMED_RESOURCE_ID_FORMAT,
+    NAMED_RESOURCE_ID_FORMAT,
+    NAMED_RESOURCE_ID_FORMAT_WITH_PARENT,
+    PROVIDER_RESOURCE_ID_WITH_VERSION,
+    REGISTRY_URI_REGEX_FORMAT,
+    REGISTRY_VERSION_PATTERN,
+    SINGULARITY_FULL_NAME_REGEX_FORMAT,
+    SINGULARITY_ID_REGEX_FORMAT,
+    SINGULARITY_SHORT_NAME_REGEX_FORMAT,
+)
+from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+
+module_logger = logging.getLogger(__name__)
+
+
+class AMLVersionedArmId(object):
+    """Parser for versioned arm id: e.g. /subscription/.../code/my- code/versions/1.
+
+    :param arm_id: The versioned ARM id.
+    :type arm_id: str
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the ARM id is incorrectly formatted.
+    """
+
+    REGEX_PATTERN = (
+        "^/?subscriptions/([^/]+)/resourceGroups/(["
+        "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/versions/(["
+        "^/]+)"
+    )
+
+    def __init__(self, arm_id=None):
+        self.is_registry_id = None
+        if arm_id:
+            match = re.match(AMLVersionedArmId.REGEX_PATTERN, arm_id)
+            if match:
+                self.subscription_id = match.group(1)
+                self.resource_group_name = match.group(2)
+                self.workspace_name = match.group(3)
+                self.asset_type = match.group(4)
+                self.asset_name = match.group(5)
+                self.asset_version = match.group(6)
+            else:
+                match = re.match(REGISTRY_VERSION_PATTERN, arm_id)
+                if match:
+                    self.asset_name = match.group(3)
+                    self.asset_version = match.group(4)
+                    self.is_registry_id = True
+                else:
+                    msg = "Invalid AzureML ARM versioned Id {}"
+                    raise ValidationException(
+                        message=msg.format(arm_id),
+                        no_personal_data_message=msg.format("[arm_id]"),
+                        error_type=ValidationErrorType.INVALID_VALUE,
+                        error_category=ErrorCategory.USER_ERROR,
+                        target=ErrorTarget.ARM_RESOURCE,
+                    )
+
+
+def get_datastore_arm_id(
+    datastore_name: Optional[str] = None, operation_scope: Optional[OperationScope] = None
+) -> Optional[str]:
+    return (
+        DATASTORE_RESOURCE_ID.format(
+            operation_scope.subscription_id,
+            operation_scope.resource_group_name,
+            operation_scope.workspace_name,
+            datastore_name,
+        )
+        if datastore_name
+        else None
+    )
+
+
+class AMLLabelledArmId(object):
+    """Parser for versioned arm id: e.g. /subscription/.../code/my- code/labels/default.
+
+    :param arm_id: The labelled ARM id.
+    :type arm_id: str
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the ARM id is incorrectly formatted.
+    """
+
+    REGEX_PATTERN = (
+        "^/?subscriptions/([^/]+)/resourceGroups/(["
+        "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/labels/(["
+        "^/]+)"
+    )
+
+    def __init__(self, arm_id=None):
+        self.is_registry_id = None
+        if arm_id:
+            match = re.match(AMLLabelledArmId.REGEX_PATTERN, arm_id)
+            if match:
+                self.subscription_id = match.group(1)
+                self.resource_group_name = match.group(2)
+                self.workspace_name = match.group(3)
+                self.asset_type = match.group(4)
+                self.asset_name = match.group(5)
+                self.asset_label = match.group(6)
+            else:
+                match = re.match(REGISTRY_VERSION_PATTERN, arm_id)
+                if match:
+                    self.asset_name = match.group(3)
+                    self.asset_label = match.group(4)
+                    self.is_registry_id = True
+                else:
+                    msg = "Invalid AzureML ARM versioned Id {}"
+                    raise ValidationException(
+                        message=msg.format(arm_id),
+                        no_personal_data_message=msg.format("[arm_id]"),
+                        error_type=ValidationErrorType.INVALID_VALUE,
+                        error_category=ErrorCategory.USER_ERROR,
+                        target=ErrorTarget.ARM_RESOURCE,
+                    )
+
+
+class AMLNamedArmId:
+    """Parser for named arm id (no version): e.g.
+
+    /subscription/.../compute/cpu-cluster.
+
+    :param arm_id: The named ARM id.
+    :type arm_id: str
+    :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted.
+    """
+
+    REGEX_PATTERN = (
+        "^/?subscriptions/([^/]+)/resourceGroups/(["
+        "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)"
+    )
+
+    REGEX_PATTERN_WITH_PARENT = (
+        "^/?subscriptions/([^/]+)/resourceGroups/(["
+        "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/([^/]+)/([^/]+)"
+    )
+
+    def __init__(self, arm_id=None):
+        if arm_id:
+            match = re.match(AMLNamedArmId.REGEX_PATTERN_WITH_PARENT, arm_id)
+            if match:
+                self.asset_name = match.group(7)
+                self.asset_type = match.group(6)
+                self.parent_asset_name = match.group(5)
+                self.parent_azureml_type = match.group(4)
+            if match is None:
+                match = re.match(AMLNamedArmId.REGEX_PATTERN, arm_id)
+                if match:
+                    self.asset_type = match.group(4)
+                    self.asset_name = match.group(5)
+                    self.parent_asset_name = None
+                    self.parent_azureml_type = None
+                else:
+                    msg = "Invalid AzureML ARM named Id {}"
+                    raise ValidationException(
+                        message=msg.format(arm_id),
+                        no_personal_data_message=msg.format("[arm_id]"),
+                        error_type=ValidationErrorType.INVALID_VALUE,
+                        error_category=ErrorCategory.USER_ERROR,
+                        target=ErrorTarget.ARM_RESOURCE,
+                    )
+
+            self.subscription_id = match.group(1)
+            self.resource_group_name = match.group(2)
+            self.workspace_name = match.group(3)
+
+
+class AMLAssetId:
+    REGEX_PATTERN = ASSET_ID_URI_REGEX_FORMAT
+
+    def __init__(self, asset_id: str):
+        """Parser for asset id.
+
+        :param asset_id: The asset id.
+        :type asset_id: str
+        :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the asset id is incorrectly formatted.
+        """
+        match = re.match(AMLAssetId.REGEX_PATTERN, asset_id)
+        if match is None:
+            msg = "Invalid AzureML Asset Id {}"
+            raise ValidationException(
+                message=msg.format(asset_id),
+                no_personal_data_message=msg.format("[asset_id]"),
+                error_type=ValidationErrorType.INVALID_VALUE,
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.ASSET,
+            )
+
+        self.location = match.group(1)
+        self.workspace_id = match.group(2)
+        self.asset_type = match.group(3)
+        self.asset_name = match.group(4)
+        self.asset_version = match.group(5)
+
+
+class AzureResourceId:
+    """Parser for a non-AzureML ARM Id.
+
+    :param arm_id: The non-AzureML ARM id.
+    :type arm_id: str
+    :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted.
+    """
+
+    REGEX_PATTERN = "^/?subscriptions/([^/]+)/resourceGroups/([^/]+)/providers/Microsoft.([^/]+)/([^/]+)/([^/]+)"
+    RESOURCEGROUP_PATTERN = "^/?subscriptions/([^/]+)/providers/Microsoft.([^/]+)/([^/]+)/([^/]+)"
+
+    def __init__(self, arm_id=None):
+        if arm_id:
+            match = re.match(AzureResourceId.REGEX_PATTERN, arm_id)
+            rg_match = re.match(AzureResourceId.RESOURCEGROUP_PATTERN, arm_id)
+            if match:
+                self.subscription_id = match.group(1)
+                self.resource_group_name = match.group(2)
+                self.provider_namespace_with_type = match.group(3) + match.group(4)
+                self.asset_type = match.group(4)
+                self.asset_name = match.group(5)
+            elif rg_match:
+                self.subscription_id = rg_match.group(1)
+                self.resource_group_name = None
+                self.asset_name = rg_match.group(4)
+                self.asset_type = rg_match.group(3)
+            else:
+                msg = "Invalid ARM Id {}"
+                raise ValidationException(
+                    message=msg.format(arm_id),
+                    no_personal_data_message=msg.format("[arm_id]"),
+                    error_type=ValidationErrorType.INVALID_VALUE,
+                    error_category=ErrorCategory.USER_ERROR,
+                    target=ErrorTarget.ARM_RESOURCE,
+                )
+
+
+class AzureStorageContainerResourceId:
+    """Parser for a Azure Storage Container ARM id.
+
+    :param arm_id: The Azure Storage Container ARM id.
+    :type arm_id: str
+    :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted.
+    """
+
+    REGEX_PATTERN = (
+        "^/?subscriptions/([^/]+)/resourceGroups/([^/]+)/providers/Microsoft.Storage"
+        "/storageAccounts/([^/]+)/blobServices/default/containers/([^/]+)"
+    )
+
+    def __init__(self, arm_id=None):
+        if arm_id:
+            match = re.match(AzureStorageContainerResourceId.REGEX_PATTERN, arm_id)
+            if match:
+                self.subscription_id = match.group(1)
+                self.resource_group_name = match.group(2)
+                self.storage_account = match.group(3)
+                self.container = match.group(4)
+            else:
+                msg = "Invalid Azure Storage Container Resource Id {}"
+                raise ValidationException(
+                    message=msg.format(arm_id),
+                    no_personal_data_message=msg.format("[arm_id]"),
+                    error_type=ValidationErrorType.INVALID_VALUE,
+                    error_category=ErrorCategory.USER_ERROR,
+                    target=ErrorTarget.ARM_RESOURCE,
+                )
+
+
+def _parse_endpoint_name_from_deployment_id(deployment_id: str) -> str:
+    REGEX_PATTERN = (
+        "^/?subscriptions/([^/]+)/resourceGroups/(["
+        "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/deployments/([^/]+)"
+    )
+    match = re.match(REGEX_PATTERN, deployment_id)
+    if match is None:
+        msg = "Invalid Deployment Id {}"
+        raise ValidationException(
+            message=msg.format(deployment_id),
+            no_personal_data_message=msg.format("[id]"),
+            error_type=ValidationErrorType.INVALID_VALUE,
+            error_category=ErrorCategory.USER_ERROR,
+            target=ErrorTarget.DEPLOYMENT,
+        )
+    return match.group(5)
+
+
+def parse_AzureML_id(name: str) -> Tuple[str, str, str]:
+    if name.startswith(ARM_ID_PREFIX):
+        name = name[len(ARM_ID_PREFIX) :]
+
+    at_splits = name.rsplit("@", 1)
+    if len(at_splits) > 1:
+        return at_splits[0], None, name[1]
+    colon_splits = name.rsplit(":", 1)
+    return (
+        colon_splits[0],
+        None if len(colon_splits) == 1 else colon_splits[1],
+        None,
+    )
+
+
+def parse_prefixed_name_version(name: str) -> Tuple[str, Optional[str]]:
+    if name.startswith(ARM_ID_PREFIX):
+        return parse_name_version(name[len(ARM_ID_PREFIX) :])
+    return parse_name_version(name)
+
+
+def parse_name_version(name: str) -> Tuple[str, Optional[str]]:
+    if name.find("/") != -1 and name[0] != "/":
+        raise ValidationException(
+            f"Could not parse {name}. If providing an ARM id, it should start with a '/'.",
+            no_personal_data_message=f"Could not parse {name}.",
+            error_type=ValidationErrorType.INVALID_VALUE,
+            error_category=ErrorCategory.USER_ERROR,
+            target=ErrorTarget.ARM_RESOURCE,
+        )
+    token_list = name.split(":")
+    if len(token_list) == 1:
+        return name, None
+    name, *version = token_list  # type: ignore
+    return name, ":".join(version)
+
+
+def parse_name_label(name: Optional[str]) -> Tuple[str, Optional[str]]:
+    if not name or (name.find("/") != -1 and name[0] != "/"):
+        raise ValidationException(
+            f"Could not parse {name}. If providing an ARM id, it should start with a '/'.",
+            no_personal_data_message=f"Could not parse {name}.",
+            error_type=ValidationErrorType.INVALID_VALUE,
+            error_category=ErrorCategory.USER_ERROR,
+            target=ErrorTarget.ARM_RESOURCE,
+        )
+    token_list = name.rpartition("@")
+    if not token_list[1]:  # separator not found
+        *_, name = token_list
+        return name, None
+    name, _, label = token_list
+    return name, label
+
+
+def is_ARM_id_for_resource(name: Any, resource_type: str = ".*", sub_workspace_resource: bool = True) -> bool:
+    if sub_workspace_resource:
+        resource_regex = NAMED_RESOURCE_ID_FORMAT.format(
+            ".*", ".*", AZUREML_RESOURCE_PROVIDER, ".*", resource_type, ".*"
+        )
+    else:
+        resource_regex = LEVEL_ONE_NAMED_RESOURCE_ID_FORMAT.format(
+            ".*", ".*", AZUREML_RESOURCE_PROVIDER, resource_type, ".*"
+        )
+    if isinstance(name, str) and re.match(resource_regex, name, re.IGNORECASE):
+        return True
+    return False
+
+
+def is_ARM_id_for_parented_resource(name: str, parent_resource_type: str, child_resource_type: str) -> bool:
+    resource_regex = NAMED_RESOURCE_ID_FORMAT_WITH_PARENT.format(
+        ".*",
+        ".*",
+        AZUREML_RESOURCE_PROVIDER,
+        ".*",
+        parent_resource_type,
+        ".*",
+        child_resource_type,
+        "*",
+    )
+    return re.match(resource_regex, name, re.IGNORECASE) is not None
+
+
+def is_registry_id_for_resource(name: Any) -> bool:
+    if isinstance(name, str) and re.match(REGISTRY_URI_REGEX_FORMAT, name, re.IGNORECASE):
+        return True
+    return False
+
+
+def is_singularity_id_for_resource(name: Any) -> bool:
+    if isinstance(name, str) and re.match(SINGULARITY_ID_REGEX_FORMAT, name, re.IGNORECASE):
+        return True
+    return False
+
+
+def is_singularity_full_name_for_resource(name: Any) -> bool:
+    if isinstance(name, str) and (re.match(SINGULARITY_FULL_NAME_REGEX_FORMAT, name, re.IGNORECASE)):
+        return True
+    return False
+
+
+def is_singularity_short_name_for_resource(name: Any) -> bool:
+    if isinstance(name, str) and re.match(SINGULARITY_SHORT_NAME_REGEX_FORMAT, name, re.IGNORECASE):
+        return True
+    return False
+
+
+def get_arm_id_with_version(
+    operation_scope: OperationScope,
+    provider_name: str,
+    provider_value: str,
+    provider_version: str,
+):
+    return PROVIDER_RESOURCE_ID_WITH_VERSION.format(
+        operation_scope.subscription_id,
+        operation_scope.resource_group_name,
+        operation_scope.workspace_name,
+        provider_name,
+        provider_value,
+        provider_version,
+    )
+
+
+def generate_data_arm_id(operation_scope: OperationScope, name: str, version: int):
+    return get_arm_id_with_version(operation_scope, DATA_ARM_TYPE, name, str(version))
+
+
+def remove_aml_prefix(resource_id: Optional[str]) -> Optional[str]:
+    if not resource_id:
+        return None
+
+    if resource_id.startswith(ARM_ID_PREFIX):
+        return resource_id[len(ARM_ID_PREFIX) :]
+    return resource_id
+
+
+def get_resource_name_from_arm_id(resource_id: str) -> str:
+    # parse arm id to datastore name
+    return AMLNamedArmId(resource_id).asset_name
+
+
+def get_resource_name_from_arm_id_safe(resource_id: str) -> str:
+    """Get the resource name from an ARM id.
+
+    :param resource_id: The resource's ARM ID
+    :type resource_id: str
+    :return:
+      * Resource Name if input string is ARM id
+      * Original input otherwise
+    :rtype: str
+    """
+    try:
+        return get_resource_name_from_arm_id(resource_id)
+    except ValidationException:
+        # already a name
+        return resource_id
+    except AttributeError:
+        # None or empty string
+        return resource_id
+    except Exception:  # pylint: disable=W0718
+        # unexpected error
+        module_logger.warning("Failed to parse resource id: %s", resource_id)
+        return resource_id
+
+
+def get_arm_id_object_from_id(
+    resource_id: str,
+) -> Union[AMLVersionedArmId, AMLNamedArmId, AzureResourceId]:
+    """Attempts to create and return one of: AMLVersionedId, AMLNamedId, AzureResoureId. In the case than an AzureML ARM
+    Id is passed in, either AMLVersionedId or AMLNamedId will be created depending on resource type In the case that a
+    non-AzureML ARM id is passed in, an AzureResourceId will be returned.
+
+    :param resource_id: the ARM Id to parse
+    :type resource_id: str
+    :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted.
+    :return: The parser for the given ARM Id
+    :rtype: Union[AMLVersionedArmId, AMLNamedArmId, AzureResourceId]
+    """
+
+    # Try each type of parser for the ARM id. If none succeed, raise a ValueError
+    try:
+        return AMLVersionedArmId(resource_id)
+    except ValidationException:
+        pass
+
+    try:
+        return AMLNamedArmId(resource_id)
+    except ValidationException:
+        pass
+
+    try:
+        return AzureResourceId(resource_id)
+    except ValidationException:
+        pass
+
+    msg = "Invalid ARM Id {}"
+    raise ValidationException(
+        message=msg.format(resource_id),
+        no_personal_data_message=msg.format("[resource_id]"),
+        error_type=ValidationErrorType.INVALID_VALUE,
+        error_category=ErrorCategory.USER_ERROR,
+        target=ErrorTarget.DEPLOYMENT,
+    )
+
+
+def remove_datastore_prefix(datastore_id: Optional[str]) -> Optional[str]:
+    if not datastore_id:
+        return None
+
+    if datastore_id.startswith(DATASTORE_SHORT_URI):
+        return datastore_id[len(DATASTORE_SHORT_URI) :]
+    return datastore_id
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_artifact_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_artifact_utils.py
new file mode 100644
index 00000000..9dafaf79
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_artifact_utils.py
@@ -0,0 +1,454 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import copy
+import hashlib
+import logging
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import zipfile
+from collections import defaultdict
+from io import BytesIO
+from pathlib import Path
+from threading import Lock
+from typing import Iterable, List, Optional, Union
+
+from typing_extensions import Literal
+
+from azure.ai.ml.constants._common import DefaultOpenEncoding
+
+from ._http_utils import HttpPipeline
+from .utils import get_base_directory_for_cache
+
+_logger = logging.getLogger(__name__)
+
+
+class ArtifactCache:
+    """Disk cache of azure artifact packages.
+
+    The key of the cache is path of artifact packages in local, like this
+    azure-ai-ml/components/additional_includes/artifacts/{organization}/{project}/{feed}/{package_name}/{version}.
+    The value is the files/folders in this cache folder.
+    """
+
+    # artifact cache is shared across SDK versions and across workspaces/registries
+    DEFAULT_DISK_CACHE_DIRECTORY = get_base_directory_for_cache().joinpath(
+        "components",
+        "additional_includes",
+        "artifacts",
+    )
+    POSTFIX_CHECKSUM = "checksum"
+    _instance_lock = Lock()
+    _instance = None
+
+    def __new__(cls):
+        """Singleton creation disk cache."""
+        if cls._instance is None:
+            with cls._instance_lock:
+                if cls._instance is None:
+                    cls._instance = object.__new__(cls)
+                    cls.check_artifact_extension()
+        return cls._instance
+
+    @staticmethod
+    def check_artifact_extension():
+        # check az extension azure-devops installed. Install it if not installed.
+        result = subprocess.run(
+            [shutil.which("az"), "artifacts", "--help", "--yes"],
+            capture_output=True,
+            check=False,
+        )
+
+        if result.returncode != 0:
+            raise RuntimeError(
+                "Auto-installation failed. Please install azure-devops "
+                "extension by 'az extension add --name azure-devops'."
+            )
+
+    def __init__(self, cache_directory=None):
+        self._cache_directory = cache_directory or self.DEFAULT_DISK_CACHE_DIRECTORY
+        Path(self._cache_directory).mkdir(exist_ok=True, parents=True)
+        self._artifacts_tool_path = None
+        self._download_locks = defaultdict(Lock)
+
+    @property
+    def cache_directory(self) -> Path:
+        """Cache directory path.
+
+        :return: The cache directory
+        :rtype: Path
+        """
+        return self._cache_directory
+
+    @staticmethod
+    def hash_files_content(file_list: List[Union[str, os.PathLike]]) -> str:
+        """Hash the file content in the file list.
+
+        :param file_list: The list of files to hash
+        :type file_list: List[Union[str, os.PathLike]]
+        :return: Hashed file contents
+        :rtype: str
+        """
+        ordered_file_list = copy.copy(file_list)
+        hasher = hashlib.sha256()
+        ordered_file_list.sort()
+        for item in ordered_file_list:
+            with open(item, "rb") as f:
+                hasher.update(f.read())
+        return hasher.hexdigest()
+
+    @staticmethod
+    def _format_organization_name(organization):
+        pattern = r'[<>:"\\/|?*]'
+        normalized_organization_name = re.sub(pattern, "_", organization)
+        return normalized_organization_name
+
+    @staticmethod
+    def get_organization_project_by_git():
+        """Get organization and project from git remote url. For example, the git remote url is
+        "https://organization.visualstudio.com/xxx/project_name/_git/repositry_name" or
+        "https://dev.azure.com/{organization}/project".
+
+        :return organization_url, project: organization_url, project
+        :rtype organization_url, project: str, str
+        """
+        result = subprocess.run(
+            [shutil.which("git"), "config", "--get", "remote.origin.url"],
+            capture_output=True,
+            encoding="utf-8",
+            check=False,
+        )
+
+        if result.returncode != 0:
+            # When organization and project cannot be retrieved from the origin url.
+            raise RuntimeError(
+                f"Get the git origin url failed, you must be in a local Git directory, "
+                f"error message: {result.stderr}"
+            )
+        origin_url = result.stdout.strip()
+
+        # Organization URL has two format, https://dev.azure.com/{organization} and
+        # https://{organization}.visualstudio.com
+        # https://learn.microsoft.com/azure/devops/extend/develop/work-with-urls?view=azure-devops&tabs=http
+        if "dev.azure.com" in origin_url:
+            regex = r"^https:\/\/\w*@?dev\.azure\.com\/(\w*)\/(\w*)"
+            results = re.findall(regex, origin_url)
+            if results:
+                organization, project = results[0]
+                return f"https://dev.azure.com/{organization}", project
+        elif "visualstudio.com" in origin_url:
+            regex = r"https:\/\/(\w*)\.visualstudio\.com.*\/(\w*)\/_git"
+            results = re.findall(regex, origin_url)
+            if results:
+                organization, project = results[0]
+                return f"https://{organization}.visualstudio.com", project
+
+        # When organization and project cannot be retrieved from the origin url.
+        raise RuntimeError(
+            f'Cannot get organization and project from git origin url "{origin_url}", '
+            f'you must be in a local Git directory that has a "remote" referencing a '
+            f"Azure DevOps or Azure DevOps Server repository."
+        )
+
+    @classmethod
+    def _get_checksum_path(cls, path):
+        artifact_path = Path(path)
+        return artifact_path.parent / f"{artifact_path.name}_{cls.POSTFIX_CHECKSUM}"
+
+    def _redirect_artifacts_tool_path(self, organization: Optional[str]):
+        """Downloads the artifacts tool and redirects `az artifact` command to it.
+
+        Done to avoid the transient issue when download artifacts
+
+        :param organization:  The organization url. If None, is determined by local git repo
+        :type organization: Optional[str]
+        """
+        from azure.identity import DefaultAzureCredential
+
+        if not organization:
+            organization, _ = self.get_organization_project_by_git()
+
+        organization_pattern = r"https:\/\/(.*)\.visualstudio\.com"
+        result = re.findall(pattern=organization_pattern, string=organization)
+        if result:
+            organization_name = result[0]
+        else:
+            organization_pattern = r"https:\/\/dev\.azure\.com\/(.*)"
+            result = re.findall(pattern=organization_pattern, string=organization)
+            if not result:
+                raise RuntimeError("Cannot find artifact organization.")
+            organization_name = result[0]
+
+        if not self._artifacts_tool_path:
+            os_name = "Windows" if os.name == "nt" else "Linux"
+            credential = DefaultAzureCredential()
+            token = credential.get_token("https://management.azure.com/.default")
+            header = {"Authorization": "Bearer " + token.token}
+
+            # The underlying HttpTransport is meant to be user configurable.
+            # MLClient instances have a user configured Pipeline for sending http requests
+            # TODO: Replace this with MlCLient._requests_pipeline
+            requests_pipeline = HttpPipeline()
+            url = (
+                f"https://{organization_name}.vsblob.visualstudio.com/_apis/clienttools/ArtifactTool/release?"
+                f"osName={os_name}&arch=AMD64"
+            )
+            response = requests_pipeline.get(  # pylint: disable=too-many-function-args,unexpected-keyword-arg
+                url, headers=header
+            )
+            if response.status_code == 200:
+                artifacts_tool_path = tempfile.mkdtemp()  # nosec B306
+                artifacts_tool_uri = response.json()["uri"]
+                response = requests_pipeline.get(artifacts_tool_uri)  # pylint: disable=too-many-function-args
+                with zipfile.ZipFile(BytesIO(response.content)) as zip_file:
+                    zip_file.extractall(artifacts_tool_path)
+                os.environ["AZURE_DEVOPS_EXT_ARTIFACTTOOL_OVERRIDE_PATH"] = str(artifacts_tool_path.resolve())
+                self._artifacts_tool_path = artifacts_tool_path
+            else:
+                _logger.warning("Download artifact tool failed: %s", response.text)
+
+    def _download_artifacts(
+        self,
+        download_cmd: Iterable[str],
+        organization: Optional[str],
+        name: str,
+        version: str,
+        feed: str,
+        max_retries: int = 3,
+    ):
+        """Download artifacts with retry.
+
+        :param download_cmd: The command used to download the artifact
+        :type download_cmd: Iterable[str]
+        :param organization: The artifact organization
+        :type organization: Optional[str]
+        :param name: The package name
+        :type name: str
+        :param version: The package version
+        :type version: str
+        :param feed: The download feed
+        :type feed: str
+        :param max_retries: The number of times to retry the download. Defaults to 3
+        :type max_retries: int
+        """
+        retries = 0
+        while retries <= max_retries:
+            try:
+                self._redirect_artifacts_tool_path(organization)
+            except Exception as e:  # pylint: disable=W0718
+                _logger.warning("Redirect artifacts tool path failed, details: %s", e)
+
+            retries += 1
+            result = subprocess.run(
+                download_cmd,
+                capture_output=True,
+                encoding="utf-8",
+                check=False,
+            )
+
+            if result.returncode != 0:
+                error_msg = (
+                    f"Download package {name}:{version} from the feed {feed} failed {retries} times: {result.stderr}"
+                )
+                if retries < max_retries:
+                    _logger.warning(error_msg)
+                else:
+                    error_msg = error_msg + f"\nDownload artifact debug info: {result.stdout}"
+                    raise RuntimeError(error_msg)
+            else:
+                return
+
+    def _check_artifacts(self, artifact_package_path: Union[str, os.PathLike]) -> bool:
+        """Check the artifact folder is legal.
+
+        :param artifact_package_path: The artifact package path
+        :type artifact_package_path: Union[str, os.PathLike]
+        :return:
+          * If the artifact folder or checksum file does not exist, return false.
+          * If the checksum file exists and does not equal to the hash of artifact folder, return False.
+          * If the checksum file equals to the hash of artifact folder, return true.
+        :rtype: bool
+        """
+        path = Path(artifact_package_path)
+        if not path.exists():
+            return False
+        checksum_path = self._get_checksum_path(artifact_package_path)
+        if checksum_path.exists():
+            with open(checksum_path, "r", encoding=DefaultOpenEncoding.READ) as f:
+                checksum = f.read()
+                file_list = [os.path.join(root, f) for root, _, files in os.walk(path) for f in files]
+                artifact_hash = self.hash_files_content(file_list)
+                return checksum == artifact_hash
+        return False
+
+    def get(
+        self,
+        feed: str,
+        name: str,
+        version: str,
+        scope: Literal["project", "organization"],
+        organization: Optional[str] = None,
+        project: Optional[str] = None,
+        resolve: bool = True,
+    ) -> Optional[Path]:
+        """Get the catch path of artifact package. Package path like this azure-ai-
+        ml/components/additional_includes/artifacts/{organization}/{project}/{feed}/{package_name}/{version}. If the
+        path exits, it will return the package path. If the path not exist and resolve=True, it will download the
+        artifact package and return package path. If the path not exist and resolve=False, it will return None.
+
+        :param feed: Name or ID of the feed.
+        :type feed: str
+        :param name: Name of the package.
+        :type name: str
+        :param version: Version of the package.
+        :type version: str
+        :param scope: Scope of the feed: 'project' if the feed was created in a project, and 'organization' otherwise.
+        :type scope: Literal["project", "organization"]
+        :param organization: Azure DevOps organization URL.
+        :type organization: str
+        :param project: Name or ID of the project.
+        :type project: str
+        :param resolve: Whether download package when package does not exist in local.
+        :type resolve: bool
+        :return artifact_package_path: Cache path of the artifact package
+        :rtype: Optional[Path]
+        """
+        if not all([organization, project]):
+            org_val, project_val = self.get_organization_project_by_git()
+            organization = organization or org_val
+            project = project or project_val
+        artifact_package_path = (
+            Path(self.DEFAULT_DISK_CACHE_DIRECTORY)
+            / self._format_organization_name(organization)
+            / project
+            / feed
+            / name
+            / version
+        )
+        # Use lock to avoid downloading the same package at the same time.
+        with self._download_locks[artifact_package_path]:
+            if self._check_artifacts(artifact_package_path):
+                # When the cache folder of artifact package exists, it's sure that the package has been downloaded.
+                return artifact_package_path.absolute().resolve()
+            if resolve:
+                check_sum_path = self._get_checksum_path(artifact_package_path)
+                if Path(check_sum_path).exists():
+                    os.unlink(check_sum_path)
+                if artifact_package_path.exists():
+                    # Remove invalid artifact package to avoid affecting download artifact.
+                    temp_folder = tempfile.mkdtemp()  # nosec B306
+                    os.rename(artifact_package_path, temp_folder)
+                    shutil.rmtree(temp_folder)
+                # Download artifact
+                return self.set(
+                    feed=feed,
+                    name=name,
+                    version=version,
+                    organization=organization,
+                    project=project,
+                    scope=scope,
+                )
+        return None
+
+    def set(
+        self,
+        feed: str,
+        name: str,
+        version: str,
+        scope: Literal["project", "organization"],
+        organization: Optional[str] = None,
+        project: Optional[str] = None,
+    ) -> Path:
+        """Set the artifact package to the cache. The key of the cache is path of artifact packages in local. The value
+        is the files/folders in this cache folder. If package path exists, directly return package path.
+
+        :param feed: Name or ID of the feed.
+        :type feed: str
+        :param name: Name of the package.
+        :type name: str
+        :param version: Version of the package.
+        :type version: str
+        :param scope: Scope of the feed: 'project' if the feed was created in a project, and 'organization' otherwise.
+        :type scope: Literal["project", "organization"]
+        :param organization: Azure DevOps organization URL.
+        :type organization: str
+        :param project: Name or ID of the project.
+        :type project: str
+        :return artifact_package_path: Cache path of the artifact package
+        :rtype: Path
+        """
+        tempdir = tempfile.mkdtemp()  # nosec B306
+        download_cmd = [
+            shutil.which("az"),
+            "artifacts",
+            "universal",
+            "download",
+            "--feed",
+            feed,
+            "--name",
+            name,
+            "--version",
+            version,
+            "--scope",
+            scope,
+            "--path",
+            tempdir,
+        ]
+        if organization:
+            download_cmd.extend(["--org", organization])
+        if project:
+            download_cmd.extend(["--project", project])
+        _logger.info("Start downloading artifacts %s:%s from %s.", name, version, feed)
+        result = subprocess.run(
+            download_cmd,
+            capture_output=True,
+            encoding="utf-8",
+            check=False,
+        )
+
+        if result.returncode != 0:
+            artifacts_tool_not_find_error_pattern = "No such file or directory: .*artifacttool"
+            if re.findall(artifacts_tool_not_find_error_pattern, result.stderr):
+                # When download artifacts tool failed retry download artifacts command
+                _logger.warning(
+                    "Download package %s:%s from the feed %s failed: %s", name, version, feed, result.stderr
+                )
+                download_cmd.append("--debug")
+                self._download_artifacts(download_cmd, organization, name, version, feed)
+            else:
+                raise RuntimeError(f"Download package {name}:{version} from the feed {feed} failed: {result.stderr}")
+        try:
+            # Copy artifact package from temp folder to the cache path.
+            if not all([organization, project]):
+                org_val, project_val = self.get_organization_project_by_git()
+                organization = organization or org_val
+                project = project or project_val
+            artifact_package_path = (
+                Path(self.DEFAULT_DISK_CACHE_DIRECTORY)
+                / self._format_organization_name(organization)
+                / project
+                / feed
+                / name
+                / version
+            )
+            artifact_package_path.parent.mkdir(exist_ok=True, parents=True)
+            file_list = [os.path.join(root, f) for root, _, files in os.walk(tempdir) for f in files]
+            artifact_hash = self.hash_files_content(file_list)
+            os.rename(tempdir, artifact_package_path)
+            temp_checksum_file = os.path.join(tempfile.mkdtemp(), f"{version}_{self.POSTFIX_CHECKSUM}")
+            with open(temp_checksum_file, "w", encoding=DefaultOpenEncoding.WRITE) as f:
+                f.write(artifact_hash)
+            os.rename(
+                temp_checksum_file,
+                artifact_package_path.parent / f"{version}_{self.POSTFIX_CHECKSUM}",
+            )
+        except (FileExistsError, PermissionError, OSError):
+            # On Windows, if dst exists a FileExistsError is always raised.
+            # On Unix, if dst is a non-empty directory, an OSError is raised.
+            # If dst is being used by another process will raise PermissionError.
+            # https://docs.python.org/3/library/os.html#os.rename
+            pass
+        return artifact_package_path.absolute().resolve()
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_asset_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_asset_utils.py
new file mode 100644
index 00000000..7081d9d6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_asset_utils.py
@@ -0,0 +1,1224 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+# pylint: disable=protected-access,too-many-lines
+
+import hashlib
+import logging
+import os
+import json
+import uuid
+import warnings
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextlib import suppress
+from multiprocessing import cpu_count
+from os import PathLike
+from pathlib import Path
+from platform import system
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
+
+from colorama import Fore
+from tqdm import TqdmWarning, tqdm
+from typing_extensions import Literal
+
+from azure.ai.ml._artifacts._constants import (
+    AML_IGNORE_FILE_NAME,
+    ARTIFACT_ORIGIN,
+    AUTO_DELETE_SETTING_NOT_ALLOWED_ERROR_NO_PERSONAL_DATA,
+    BLOB_STORAGE_CLIENT_NAME,
+    CHUNK_SIZE,
+    DEFAULT_CONNECTION_TIMEOUT,
+    EMPTY_DIRECTORY_ERROR,
+    GEN2_STORAGE_CLIENT_NAME,
+    GIT_IGNORE_FILE_NAME,
+    INVALID_MANAGED_DATASTORE_PATH_ERROR_NO_PERSONAL_DATA,
+    MAX_CONCURRENCY,
+    PROCESSES_PER_CORE,
+    UPLOAD_CONFIRMATION,
+    WORKSPACE_MANAGED_DATASTORE,
+    WORKSPACE_MANAGED_DATASTORE_WITH_SLASH,
+)
+from azure.ai.ml._restclient.v2022_02_01_preview.operations import (
+    ComponentContainersOperations,
+    ComponentVersionsOperations,
+    DataContainersOperations,
+    DataVersionsOperations,
+    EnvironmentContainersOperations,
+    EnvironmentVersionsOperations,
+    ModelContainersOperations,
+    ModelVersionsOperations,
+)
+from azure.ai.ml._restclient.v2022_05_01.models import (
+    DataVersionBaseData,
+    ModelVersionData,
+    ModelVersionResourceArmPaginatedResult,
+)
+from azure.ai.ml._restclient.v2023_04_01.models import PendingUploadRequestDto
+from azure.ai.ml._utils._pathspec import GitWildMatchPattern, normalize_file
+from azure.ai.ml._utils.utils import convert_windows_path_to_unix, retry, snake_to_camel
+from azure.ai.ml.constants._common import (
+    MAX_AUTOINCREMENT_ATTEMPTS,
+    DefaultOpenEncoding,
+    OrderString,
+)
+from azure.ai.ml.entities._assets.asset import Asset
+from azure.ai.ml.exceptions import (
+    AssetPathException,
+    EmptyDirectoryError,
+    ErrorCategory,
+    ErrorTarget,
+    ValidationErrorType,
+    ValidationException,
+)
+from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
+
+if TYPE_CHECKING:
+    from azure.ai.ml.operations import (
+        ComponentOperations,
+        DataOperations,
+        EnvironmentOperations,
+        IndexOperations,
+        ModelOperations,
+    )
+
+hash_type = type(hashlib.md5())  # nosec
+
+module_logger = logging.getLogger(__name__)
+
+
+class AssetNotChangedError(Exception):
+    pass
+
+
+class IgnoreFile(object):
+    def __init__(self, file_path: Optional[Union[str, os.PathLike]] = None):
+        """Base class for handling .gitignore and .amlignore files.
+
+        :param file_path: Relative path, or absolute path to the ignore file.
+        """
+        path = Path(file_path).resolve() if file_path else None
+        self._path = path
+        self._path_spec = None
+
+    def exists(self) -> bool:
+        """Checks if ignore file exists.
+        :return: True if file exists. False Otherwise
+        :rtype: bool
+        """
+        return self._file_exists()
+
+    def _file_exists(self) -> bool:
+        return self._path and self._path.exists()
+
+    @property
+    def base_path(self) -> Path:
+        return self._path.parent
+
+    def _get_ignore_list(self) -> List[str]:
+        """Get ignore list from ignore file contents.
+
+        :return: The lines of the ignore file
+        :rtype: List[str]
+        """
+        if not self.exists():
+            return []
+        if self._file_exists():
+            with open(self._path, "r", encoding=DefaultOpenEncoding.READ) as fh:
+                return [line.rstrip() for line in fh if line]
+        return []
+
+    def _create_pathspec(self) -> List[GitWildMatchPattern]:
+        """Creates path specification based on ignore list.
+
+        :return: Path specification
+        :rtype: List[GitWildMatchPattern]
+        """
+        return [GitWildMatchPattern(ignore) for ignore in self._get_ignore_list()]
+
+    def _get_rel_path(self, file_path: Union[str, os.PathLike]) -> Optional[str]:
+        """Get relative path of given file_path.
+
+        :param file_path: A file path
+        :type file_path: Union[str, os.PathLike]
+        :return: file_path relative to base_path, if computable. None otherwise
+        :rtype: Optional[str]
+        """
+        file_path = Path(file_path).absolute()
+        try:
+            # use os.path.relpath instead of Path.relative_to in case file_path is not a child of self.base_path
+            return os.path.relpath(file_path, self.base_path)
+        except ValueError:
+            # 2 paths are on different drives
+            return None
+
+    def is_file_excluded(self, file_path: Union[str, os.PathLike]) -> bool:
+        """Checks if given file_path is excluded.
+
+        :param file_path: File path to be checked against ignore file specifications
+        :type file_path: Union[str, os.PathLike]
+        :return: Whether the file is excluded by ignore file
+        :rtype: bool
+        """
+        # TODO: current design of ignore file can't distinguish between files and directories of the same name
+        if self._path_spec is None:
+            self._path_spec = self._create_pathspec()
+        if not self._path_spec:
+            return False
+        file_path = self._get_rel_path(file_path)
+        if file_path is None:
+            return True
+
+        norm_file = normalize_file(file_path)
+        matched = False
+        for pattern in self._path_spec:
+            if pattern.include is not None:
+                if pattern.match_file(norm_file) is not None:
+                    matched = pattern.include
+
+        return matched
+
+    @property
+    def path(self) -> Union[Path, str]:
+        return self._path
+
+
+class AmlIgnoreFile(IgnoreFile):
+    def __init__(self, directory_path: Union[Path, str]):
+        file_path = Path(directory_path).joinpath(AML_IGNORE_FILE_NAME)
+        super(AmlIgnoreFile, self).__init__(file_path)
+
+
+class GitIgnoreFile(IgnoreFile):
+    def __init__(self, directory_path: Union[Path, str]):
+        file_path = Path(directory_path).joinpath(GIT_IGNORE_FILE_NAME)
+        super(GitIgnoreFile, self).__init__(file_path)
+
+
+def get_ignore_file(directory_path: Union[Path, str]) -> IgnoreFile:
+    """Finds and returns IgnoreFile object based on ignore file found in directory_path.
+
+    .amlignore takes precedence over .gitignore and if no file is found, an empty
+    IgnoreFile object will be returned.
+
+    The ignore file must be in the root directory.
+
+    :param directory_path: Path to the (root) directory where ignore file is located
+    :type directory_path: Union[Path, str]
+    :return: The IgnoreFile found in the directory
+    :rtype: IgnoreFile
+    """
+    aml_ignore = AmlIgnoreFile(directory_path)
+    git_ignore = GitIgnoreFile(directory_path)
+
+    if aml_ignore.exists():
+        return aml_ignore
+    if git_ignore.exists():
+        return git_ignore
+    return IgnoreFile()
+
+
+def _validate_path(path: Union[str, os.PathLike], _type: str) -> None:
+    path = Path(path)  # Okay to do this since Path is idempotent
+    if not path.is_file() and not path.is_dir():
+        raise ValidationException(
+            message=f"No such file or directory: {path}",
+            target=_type,
+            error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND,
+            no_personal_data_message="No such file or directory",
+            error_category=ErrorCategory.USER_ERROR,
+        )
+
+
+def _parse_name_version(
+    name: Optional[str] = None, version_as_int: bool = True
+) -> Tuple[Optional[str], Optional[Union[str, int]]]:
+    if not name:
+        return None, None
+
+    token_list = name.split(":")
+    if len(token_list) == 1:
+        return name, None
+    *name, version = token_list
+    if version_as_int:
+        version = int(version)
+    return ":".join(name), version
+
+
+def _get_file_hash(filename: Union[str, os.PathLike], _hash: hash_type) -> hash_type:
+    with open(str(filename), "rb") as f:
+        for chunk in iter(lambda: f.read(CHUNK_SIZE), b""):
+            _hash.update(chunk)
+    return _hash
+
+
+def delete_two_catalog_files(path):
+    """
+    Function that deletes the "catalog.json" and "catalog.json.sig" files located at 'path', if they exist
+
+    :param path: Path to the folder for signing
+    :type path: Union[Path, str]
+    :return: None
+    """
+    # catalog.json
+    file_path_json = os.path.join(path, "catalog.json")
+    if os.path.exists(file_path_json):
+        module_logger.warning("%s already exists. Deleting it", file_path_json)
+        os.remove(file_path_json)
+    # catalog.json.sig
+    file_path_json_sig = os.path.join(path, "catalog.json.sig")
+    if os.path.exists(file_path_json_sig):
+        module_logger.warning("%s already exists. Deleting it", file_path_json_sig)
+        os.remove(file_path_json_sig)
+
+
+def create_catalog_files(path, json_stub):
+    with open(os.path.join(path, "catalog.json"), "w", encoding=DefaultOpenEncoding.WRITE) as jsonFile1:
+        json.dump(json_stub, jsonFile1)
+    with open(os.path.join(path, "catalog.json.sig"), "w", encoding=DefaultOpenEncoding.WRITE) as jsonFile2:
+        json.dump(json_stub, jsonFile2)
+
+
+def _get_dir_hash(directory: Union[str, os.PathLike], _hash: hash_type, ignore_file: IgnoreFile) -> hash_type:
+    dir_contents = Path(directory).iterdir()
+    sorted_contents = sorted(dir_contents, key=lambda path: str(path).lower())
+    for path in sorted_contents:
+        if ignore_file.is_file_excluded(path):
+            continue
+        _hash.update(path.name.encode())
+        if os.path.islink(path):  # ensure we're hashing the contents of the linked file
+            path = _resolve_path(path)
+        if path.is_file():
+            _hash = _get_file_hash(path, _hash)
+        elif path.is_dir():
+            _hash = _get_dir_hash(path, _hash, ignore_file)
+    return _hash
+
+
+def _build_metadata_dict(name: str, version: str) -> Dict[str, str]:
+    """Build metadata dictionary to attach to uploaded data.
+
+    Metadata includes an upload confirmation field, and for code uploads only, the name and version of the code asset
+    being created for that data.
+
+    :param name: The name of the uploaded data
+    :type name: str
+    :param version: The version of the uploaded data
+    :type version: str
+    :return: Metadata dict
+    :rtype: Dict[str, str]
+    """
+    if name:
+        linked_asset_arm_id = {"name": name, "version": version}
+    else:
+        msg = "'name' cannot be NoneType for asset artifact upload."
+        raise ValidationException(
+            message=msg,
+            no_personal_data_message=msg,
+            target=ErrorTarget.ASSET,
+            error_category=ErrorCategory.USER_ERROR,
+            error_type=ValidationErrorType.INVALID_VALUE,
+        )
+
+    metadata_dict = {**UPLOAD_CONFIRMATION, **linked_asset_arm_id}
+    return metadata_dict
+
+
+def get_object_hash(path: Union[str, os.PathLike], ignore_file: IgnoreFile = IgnoreFile()) -> str:
+    _hash = hashlib.md5(b"Initialize for october 2021 AML CLI version")  # nosec
+    if Path(path).is_dir():
+        object_hash = _get_dir_hash(directory=path, _hash=_hash, ignore_file=ignore_file)
+    else:
+        if os.path.islink(path):  # ensure we're hashing the contents of the linked file
+            path = _resolve_path(Path(path))
+        object_hash = _get_file_hash(filename=path, _hash=_hash)
+    return str(object_hash.hexdigest())
+
+
+def get_content_hash_version():
+    return 202208
+
+
+def get_content_hash(path: Union[str, os.PathLike], ignore_file: IgnoreFile = IgnoreFile()) -> Optional[str]:
+    """Generating sha256 hash for file/folder,
+
+    e.g. Code snapshot fingerprints to prevent tampering.
+
+    The process of hashing is:
+    1. If it's a link, get the actual path of the link.
+    2. If it's a file, append file content.
+    3. If it's a folder:
+        1. list all files under the folder
+        2. convert file count to str and append to hash
+        3. sort the files by lower case of relative path
+        4. for each file append '#'+relative path+'#' and file size to hash
+        5. do another iteration on file list to append each files content to hash.
+        The example of absolute path to relative path mapping is:
+        [
+            ('/mnt/c/codehash/code/file1.txt', 'file1.txt'),
+            ('/mnt/c/codehash/code/folder1/file1.txt', 'folder1/file1.txt'),
+            ('/mnt/c/codehash/code/Folder2/file1.txt', 'Folder2/file1.txt'),
+            ('/mnt/c/codehash/code/Folder2/folder1/file1.txt', 'Folder2/folder1/file1.txt')
+        ]
+    4. Hash the content and convert to hex digest string.
+
+    :param path: The directory to calculate the size of
+    :type path: Union[str, os.PathLike]
+    :param ignore_file: An ignore file that specifies files to ignore when computing the size
+    :type ignore_file: IgnoreFile
+    :return: The content hash if the content is a link, directory, or file. None otherwise
+    :rtype: Optional[str]
+    """
+    # DO NOT change this function unless you change the verification logic together
+    actual_path = path
+    if os.path.islink(path):
+        actual_path = _resolve_path(Path(path)).as_posix()
+    if os.path.isdir(actual_path):
+        return _get_file_list_content_hash(get_upload_files_from_folder(actual_path, ignore_file=ignore_file))
+    if os.path.isfile(actual_path):
+        return _get_file_list_content_hash([(actual_path, Path(actual_path).name)])
+    return None
+
+
+def get_upload_files_from_folder(
+    path: Union[str, os.PathLike],
+    *,
+    prefix: str = "",
+    ignore_file: IgnoreFile = IgnoreFile(),
+) -> List[str]:
+    path = Path(path)
+    upload_paths = []
+    for root, _, files in os.walk(path, followlinks=True):
+        upload_paths += list(
+            traverse_directory(
+                root,
+                files,
+                prefix=Path(prefix).joinpath(Path(root).relative_to(path)).as_posix(),
+                ignore_file=ignore_file,
+            )
+        )
+    return upload_paths
+
+
+def _get_file_list_content_hash(file_list) -> str:
+    # file_list is a list of tuples, (absolute_path, relative_path)
+
+    _hash = hashlib.sha256()
+    # Add file count to the hash and add '#' around file name then add each file's size to avoid collision like:
+    # Case 1:
+    # 'a.txt' with contents 'a'
+    # 'b.txt' with contents 'b'
+    #
+    # Case 2:
+    # cspell:disable-next-line
+    # 'a.txt' with contents 'ab.txtb'
+    _hash.update(str(len(file_list)).encode())
+    # Sort by "destination" path, since in this function destination prefix is empty and keep the link name in path.
+    for file_path, file_name in sorted(file_list, key=lambda x: str(x[1]).lower()):
+        _hash.update(("#" + file_name + "#").encode())
+        _hash.update(str(os.path.getsize(file_path)).encode())
+    for file_path, file_name in sorted(file_list, key=lambda x: str(x[1]).lower()):
+        _hash = _get_file_hash(file_path, _hash)
+    return str(_hash.hexdigest())
+
+
+def traverse_directory(  # pylint: disable=unused-argument
+    root: str,
+    files: List[str],
+    *,
+    prefix: str,
+    ignore_file: IgnoreFile = IgnoreFile(),
+    # keep this for backward compatibility
+    **kwargs: Any,
+) -> Iterable[Tuple[str, Union[str, Any]]]:
+    """Enumerate all files in the given directory and compose paths for them to be uploaded to in the remote storage.
+    e.g.
+
+    [/mnt/c/Users/dipeck/upload_files/my_file1.txt,
+    /mnt/c/Users/dipeck/upload_files/my_file2.txt] -->
+
+        [(/mnt/c/Users/dipeck/upload_files/my_file1.txt, LocalUpload/<guid>/upload_files/my_file1.txt),
+        (/mnt/c/Users/dipeck/upload_files/my_file2.txt, LocalUpload/<guid>/upload_files/my_file2.txt))]
+
+    :param root: Root directory path
+    :type root: str
+    :param files: List of all file paths in the directory
+    :type files: List[str]
+    :keyword prefix: Remote upload path for project directory (e.g. LocalUpload/<guid>/project_dir)
+    :paramtype prefix: str
+    :keyword ignore_file: The .amlignore or .gitignore file in the project directory
+    :paramtype ignore_file: azure.ai.ml._utils._asset_utils.IgnoreFile
+    :return: Zipped list of tuples representing the local path and remote destination path for each file
+    :rtype: Iterable[Tuple[str, Union[str, Any]]]
+    """
+    # Normalize Windows paths. Note that path should be resolved first as long part will be converted to a shortcut in
+    # Windows. For example, C:\Users\too-long-user-name\test will be converted to C:\Users\too-lo~1\test by default.
+    # Refer to https://en.wikipedia.org/wiki/8.3_filename for more details.
+    root = Path(root).resolve().absolute()
+
+    # filter out files excluded by the ignore file
+    # TODO: inner ignore file won't take effect. A merged IgnoreFile need to be generated in code resolution.
+    origin_file_paths = [
+        root.joinpath(filename)
+        for filename in files
+        if not ignore_file.is_file_excluded(root.joinpath(filename).as_posix())
+    ]
+
+    result = []
+    for origin_file_path in origin_file_paths:
+        relative_path = origin_file_path.relative_to(root)
+        result.append(
+            (
+                _resolve_path(origin_file_path).as_posix(),
+                Path(prefix).joinpath(relative_path).as_posix(),
+            )
+        )
+    return result
+
+
+def _resolve_path(path: Path) -> Path:
+    if not path.is_symlink():
+        return path
+
+    link_path = path.resolve()
+    if not link_path.is_absolute():
+        link_path = path.parent.joinpath(link_path).resolve()
+    return _resolve_path(link_path)
+
+
+def generate_asset_id(asset_hash: str, include_directory=True) -> str:
+    asset_id = asset_hash or str(uuid.uuid4())
+    if include_directory:
+        asset_id = "/".join((ARTIFACT_ORIGIN, asset_id))
+    return asset_id
+
+
+def get_directory_size(
+    root: Union[str, os.PathLike], ignore_file: IgnoreFile = IgnoreFile(None)
+) -> Tuple[int, Dict[str, int]]:
+    """Returns total size of a directory and a dictionary itemizing each sub- path and its size.
+
+    If an optional ignore_file argument is provided, then files specified in the ignore file are not included in the
+    directory size calculation.
+
+    :param root: The directory to calculate the size of
+    :type root: Union[str, os.PathLike]
+    :param ignore_file: An ignore file that specifies files to ignore when computing the size
+    :type ignore_file: IgnoreFile
+    :return: The computed size of the directory, and the sizes of the child paths
+    :rtype: Tuple[int, Dict[str, int]]
+    """
+    total_size = 0
+    size_list = {}
+    for dirpath, _, filenames in os.walk(root, followlinks=True):
+        for name in filenames:
+            full_path = os.path.join(dirpath, name)
+            # Don't count files that are excluded by an ignore file
+            if ignore_file.is_file_excluded(full_path):
+                continue
+            if not os.path.islink(full_path):
+                path_size = os.path.getsize(full_path)
+            else:
+                # ensure we're counting the size of the linked file
+                # os.readlink returns a file path relative to dirpath, and must be
+                # re-joined to get a workable result
+                path_size = os.path.getsize(os.path.join(dirpath, os.readlink(convert_windows_path_to_unix(full_path))))
+            size_list[full_path] = path_size
+            total_size += path_size
+    return total_size, size_list
+
+
+def upload_file(
+    storage_client: Union["BlobStorageClient", "Gen2StorageClient"],
+    source: str,
+    dest: Optional[str] = None,
+    msg: Optional[str] = None,
+    size: int = 0,
+    show_progress: Optional[bool] = None,
+    in_directory: bool = False,
+    callback: Optional[Any] = None,
+) -> None:
+    """Upload a single file to remote storage.
+
+    :param storage_client: Storage client object
+    :type storage_client: Union[
+        azure.ai.ml._artifacts._blob_storage_helper.BlobStorageClient,
+        azure.ai.ml._artifacts._gen2_storage_helper.Gen2StorageClient]
+    :param source: Local path to project directory
+    :type source: str
+    :param dest: Remote upload path for project directory (e.g. LocalUpload/<guid>/project_dir)
+    :type dest: str
+    :param msg: Message to be shown with progress bar (e.g. "Uploading <source>")
+    :type msg: str
+    :param size: Size of the file in bytes
+    :type size: int
+    :param show_progress: Whether to show progress bar or not
+    :type show_progress: bool
+    :param in_directory: Whether the file is part of a directory of files
+    :type in_directory: bool
+    :param callback: Callback to progress bar
+    :type callback: Any
+    :return: None
+    """
+    validate_content = size > 0  # don't do checksum for empty files
+
+    if (
+        type(storage_client).__name__ == GEN2_STORAGE_CLIENT_NAME
+    ):  # Only for Gen2StorageClient, Blob Storage doesn't have true directories
+        if in_directory:
+            storage_client.temp_sub_directory_client = None
+            file_name_tail = dest.split(os.path.sep)[-1]
+            # Indexing from 2 because the first two parts of the remote path will always be LocalUpload/<asset_id>
+            all_sub_folders = dest.split(os.path.sep)[2:-1]
+
+            # Create remote directories for each nested directory if file is in a nested directory
+            for sub_folder in all_sub_folders:
+                if storage_client.temp_sub_directory_client:
+                    storage_client.temp_sub_directory_client = (
+                        storage_client.temp_sub_directory_client.create_sub_directory(sub_folder)
+                    )
+                else:
+                    storage_client.temp_sub_directory_client = storage_client.directory_client.create_sub_directory(
+                        sub_folder
+                    )
+
+            storage_client.file_client = storage_client.temp_sub_directory_client.create_file(file_name_tail)
+        else:
+            storage_client.file_client = storage_client.directory_client.create_file(source.split("/")[-1])
+
+    with open(source, "rb") as data:
+        if show_progress and not in_directory:
+            file_size, _ = get_directory_size(source)
+            file_size_in_mb = file_size / 10**6
+            if file_size_in_mb < 1:
+                msg += Fore.GREEN + " (< 1 MB)"
+            else:
+                msg += Fore.GREEN + f" ({round(file_size_in_mb, 2)} MBs)"
+            cntx_manager = FileUploadProgressBar(msg=msg)
+        else:
+            cntx_manager = suppress()
+
+        with cntx_manager as c:
+            callback = c.update_to if (show_progress and not in_directory) else None
+            if type(storage_client).__name__ == GEN2_STORAGE_CLIENT_NAME:
+                storage_client.file_client.upload_data(
+                    data=data.read(),
+                    overwrite=True,
+                    validate_content=validate_content,
+                    raw_response_hook=callback,
+                    max_concurrency=MAX_CONCURRENCY,
+                )
+            elif type(storage_client).__name__ == BLOB_STORAGE_CLIENT_NAME:
+                storage_client.container_client.upload_blob(
+                    name=dest,
+                    data=data,
+                    validate_content=validate_content,
+                    overwrite=storage_client.overwrite,
+                    raw_response_hook=callback,
+                    max_concurrency=MAX_CONCURRENCY,
+                    connection_timeout=DEFAULT_CONNECTION_TIMEOUT,
+                )
+
+    storage_client.uploaded_file_count += 1
+
+
+def upload_directory(
+    storage_client: Union["BlobStorageClient", "Gen2StorageClient"],
+    source: Union[str, os.PathLike],
+    dest: str,
+    msg: str,
+    show_progress: bool,
+    ignore_file: IgnoreFile,
+) -> None:
+    """Upload directory to remote storage.
+
+    :param storage_client: Storage client object
+    :type storage_client: Union[
+        azure.ai.ml._artifacts._blob_storage_helper.BlobStorageClient,
+        azure.ai.ml._artifacts._gen2_storage_helper.Gen2StorageClient]
+    :param source: Local path to project directory
+    :type source: Union[str, os.PathLike]
+    :param dest: Remote upload path for project directory (e.g. LocalUpload/<guid>/project_dir)
+    :type dest: str
+    :param msg: Message to be shown with progress bar (e.g. "Uploading <source>")
+    :type msg: str
+    :param show_progress: Whether to show progress bar or not
+    :type show_progress: bool
+    :param ignore_file: The .amlignore or .gitignore file in the project directory
+    :type ignore_file: azure.ai.ml._utils._asset_utils.IgnoreFile
+    :return: None
+    """
+    source_path = Path(source).resolve()
+    prefix = "" if dest == "" else dest + "/"
+    prefix += os.path.basename(source_path) + "/"
+
+    if (
+        type(storage_client).__name__ == GEN2_STORAGE_CLIENT_NAME
+    ):  # Only for Gen2StorageClient, Blob Storage doesn't have true directories
+        storage_client.sub_directory_client = storage_client.directory_client.create_sub_directory(
+            prefix.strip("/").split("/")[-1]
+        )
+
+    # Enumerate all files in the given directory and compose paths for them to be uploaded to in the remote storage
+    upload_paths = get_upload_files_from_folder(
+        source_path,
+        prefix=prefix,
+        ignore_file=ignore_file,
+    )
+    size_dict = {}
+    total_size = 0
+
+    # Get each file's size for progress bar tracking
+    for path, _ in upload_paths:
+        # TODO: symbol links are already resolved
+        if os.path.islink(path):
+            path_size = os.path.getsize(
+                os.readlink(convert_windows_path_to_unix(path))
+            )  # ensure we're counting the size of the linked file
+        else:
+            path_size = os.path.getsize(path)
+        size_dict[path] = path_size
+        total_size += path_size
+
+    upload_paths = sorted(upload_paths)
+    if len(upload_paths) == 0:
+        raise EmptyDirectoryError(
+            message=EMPTY_DIRECTORY_ERROR.format(source),
+            no_personal_data_message=msg.format("[source]"),
+            target=ErrorTarget.ARTIFACT,
+            error_category=ErrorCategory.USER_ERROR,
+        )
+    storage_client.total_file_count = len(upload_paths)
+
+    if (
+        type(storage_client).__name__ == BLOB_STORAGE_CLIENT_NAME
+    ):  # Only for Gen2StorageClient, Blob Storage doesn't have true directories
+        # Only for BlobStorageClient
+        # Azure Blob doesn't allow metadata setting at the directory level, so the first
+        # file in the directory is designated as the file where the confirmation metadata
+        # will be added at the end of the upload.
+        storage_client.indicator_file = upload_paths[0][1]
+        storage_client.check_blob_exists()
+
+    # Submit paths to workers for upload
+    num_cores = int(cpu_count()) * PROCESSES_PER_CORE
+    with ThreadPoolExecutor(max_workers=num_cores) as ex:
+        futures_dict = {
+            ex.submit(
+                upload_file,
+                storage_client=storage_client,
+                source=src,
+                dest=dest,
+                size=size_dict.get(src),
+                in_directory=True,
+                show_progress=show_progress,
+            ): (src, dest)
+            for (src, dest) in upload_paths
+        }
+        if show_progress:
+            warnings.simplefilter("ignore", category=TqdmWarning)
+            msg += f" ({round(total_size/10**6, 2)} MBs)"
+            is_windows = system() == "Windows"  # Default unicode progress bar doesn't display well on Windows
+            with tqdm(total=total_size, desc=msg, ascii=is_windows) as pbar:
+                for future in as_completed(futures_dict):
+                    future.result()  # access result to propagate any exceptions
+                    file_path_name = futures_dict[future][0]
+                    pbar.update(size_dict.get(file_path_name) or 0)
+
+
+@retry(
+    exceptions=ResourceExistsError,
+    failure_msg="Asset creation exceeded maximum retries.",
+    logger=module_logger,
+    max_attempts=MAX_AUTOINCREMENT_ATTEMPTS,
+)
+def _create_or_update_autoincrement(
+    name: str,
+    body: Any,
+    version_operation: Any,
+    container_operation: Any,
+    resource_group_name: str,
+    workspace_name: str,
+    **kwargs,
+) -> Any:
+    try:
+        container = container_operation.get(
+            name=name,
+            resource_group_name=resource_group_name,
+            workspace_name=workspace_name,
+            **kwargs,
+        )
+        version = container.properties.next_version
+
+    except ResourceNotFoundError:
+        version = "1"
+
+    result = version_operation.create_or_update(
+        name=name,
+        version=version,
+        resource_group_name=resource_group_name,
+        workspace_name=workspace_name,
+        body=body,
+        **kwargs,
+    )
+    return result
+
+
+def _get_next_version_from_container(
+    name: str,
+    container_operation: Any,
+    resource_group_name: str,
+    workspace_name: str,
+    registry_name: str = None,
+    **kwargs,
+) -> str:
+    try:
+        container = (
+            container_operation.get(
+                name=name,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+                **kwargs,
+            )
+            if registry_name
+            else container_operation.get(
+                name=name,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+                **kwargs,
+            )
+        )
+        version = container.properties.next_version
+
+    except ResourceNotFoundError:
+        version = "1"
+    return version
+
+
+def _get_next_latest_versions_from_container(
+    name: str,
+    container_operation: Any,
+    resource_group_name: str,
+    workspace_name: str,
+    registry_name: str = None,
+    **kwargs,
+) -> str:
+    try:
+        container = (
+            container_operation.get(
+                name=name,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+                **kwargs,
+            )
+            if registry_name
+            else container_operation.get(
+                name=name,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+                **kwargs,
+            )
+        )
+        next_version = container.properties.next_version
+        latest_version = container.properties.latest_version
+
+    except ResourceNotFoundError:
+        next_version = "1"
+        latest_version = "1"
+    return next_version, latest_version
+
+
+def _get_latest_version_from_container(
+    asset_name: str,
+    container_operation: Any,
+    resource_group_name: str,
+    workspace_name: Optional[str] = None,
+    registry_name: Optional[str] = None,
+    **kwargs,
+) -> str:
+    try:
+        container = (
+            container_operation.get(
+                name=asset_name,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+                **kwargs,
+            )
+            if registry_name
+            else container_operation.get(
+                name=asset_name,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+                **kwargs,
+            )
+        )
+        version = container.properties.latest_version
+
+    except ResourceNotFoundError as e:
+        message = (
+            f"Asset {asset_name} does not exist in registry {registry_name}."
+            if registry_name
+            else f"Asset {asset_name} does not exist in workspace {workspace_name}."
+        )
+        no_personal_data_message = (
+            "Asset {asset_name} does not exist in registry {registry_name}."
+            if registry_name
+            else "Asset {asset_name} does not exist in workspace {workspace_name}."
+        )
+        raise ValidationException(
+            message=message,
+            no_personal_data_message=no_personal_data_message,
+            target=ErrorTarget.ASSET,
+            error_category=ErrorCategory.USER_ERROR,
+            error_type=ValidationErrorType.RESOURCE_NOT_FOUND,
+        ) from e
+    return version
+
+
+def _get_latest(
+    asset_name: str,
+    version_operation: Any,
+    resource_group_name: str,
+    workspace_name: Optional[str] = None,
+    registry_name: Optional[str] = None,
+    order_by: Literal[OrderString.CREATED_AT, OrderString.CREATED_AT_DESC] = OrderString.CREATED_AT_DESC,
+    **kwargs,
+) -> Union[ModelVersionData, DataVersionBaseData]:
+    """Retrieve the latest version of the asset with the given name.
+
+    Latest is defined as the most recently created, not the most recently updated.
+
+    :param asset_name: The asset name
+    :type asset_name: str
+    :param version_operation: Any
+    :type version_operation: Any
+    :param resource_group_name: The resource group name
+    :type resource_group_name: str
+    :param workspace_name: The workspace name
+    :type workspace_name: Optional[str]
+    :param registry_name: The registry name
+    :type registry_name: Optional[str]
+    :param order_by: Specifies how to order the results. Defaults to :attr:`OrderString.CREATED_AT_DESC`
+    :type order_by: Literal[OrderString.CREATED_AT, OrderString.CREATED_AT_DESC]
+    :return: The latest version of the requested asset
+    :rtype: Union[ModelVersionData, DataVersionBaseData]
+    """
+    result = (
+        version_operation.list(
+            name=asset_name,
+            resource_group_name=resource_group_name,
+            registry_name=registry_name,
+            order_by=order_by,
+            top=1,
+            **kwargs,
+        )
+        if registry_name
+        else version_operation.list(
+            name=asset_name,
+            resource_group_name=resource_group_name,
+            workspace_name=workspace_name,
+            order_by=order_by,
+            top=1,
+            **kwargs,
+        )
+    )
+    try:
+        latest = result.next()
+    except StopIteration:
+        latest = None
+
+    if latest and isinstance(latest, ModelVersionResourceArmPaginatedResult):
+        # Data list return object doesn't require this since its elements are already DatasetVersionResources
+        latest = cast(ModelVersionData, latest)
+    if not latest:
+        message = (
+            f"Asset {asset_name} does not exist in registry {registry_name}."
+            if registry_name
+            else f"Asset {asset_name} does not exist in workspace {workspace_name}."
+        )
+        no_personal_data_message = (
+            "Asset {asset_name} does not exist in registry {registry_name}."
+            if registry_name
+            else "Asset {asset_name} does not exist in workspace {workspace_name}."
+        )
+        raise ValidationException(
+            message=message,
+            no_personal_data_message=no_personal_data_message,
+            target=ErrorTarget.ASSET,
+            error_category=ErrorCategory.USER_ERROR,
+            error_type=ValidationErrorType.RESOURCE_NOT_FOUND,
+        )
+    return latest
+
+
+def _archive_or_restore(
+    asset_operations: Union[
+        "DataOperations",
+        "EnvironmentOperations",
+        "ModelOperations",
+        "ComponentOperations",
+    ],
+    version_operation: Union[
+        "DataVersionsOperations",
+        "EnvironmentVersionsOperations",
+        "ModelVersionsOperations",
+        "ComponentVersionsOperations",
+    ],
+    container_operation: Union[
+        "DataContainersOperations",
+        "EnvironmentContainersOperations",
+        "ModelContainersOperations",
+        "ComponentContainersOperations",
+    ],
+    is_archived: bool,
+    name: str,
+    version: Optional[str] = None,
+    label: Optional[str] = None,
+) -> None:
+    resource_group_name = asset_operations._operation_scope._resource_group_name
+    workspace_name = asset_operations._workspace_name
+    registry_name = asset_operations._registry_name
+    if version and label:
+        msg = "Cannot specify both version and label."
+        raise ValidationException(
+            message=msg,
+            no_personal_data_message=msg,
+            target=ErrorTarget.ASSET,
+            error_category=ErrorCategory.USER_ERROR,
+            error_type=ValidationErrorType.RESOURCE_NOT_FOUND,
+        )
+    if label:
+        version = _resolve_label_to_asset(asset_operations, name, label).version
+
+    if version:
+        version_resource = (
+            version_operation.get(
+                name=name,
+                version=version,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+            )
+            if registry_name
+            else version_operation.get(
+                name=name,
+                version=version,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+            )
+        )
+        version_resource.properties.is_archived = is_archived
+        version_resource.properties.stage = None
+        (  # pylint: disable=expression-not-assigned
+            version_operation.begin_create_or_update(
+                name=name,
+                version=version,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+                body=version_resource,
+            )
+            if registry_name
+            else version_operation.create_or_update(
+                name=name,
+                version=version,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+                body=version_resource,
+            )
+        )
+    else:
+        container_resource = (
+            container_operation.get(
+                name=name,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+            )
+            if registry_name
+            else container_operation.get(
+                name=name,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+            )
+        )
+        container_resource.properties.is_archived = is_archived
+        (  # pylint: disable=expression-not-assigned
+            container_operation.create_or_update(
+                name=name,
+                resource_group_name=resource_group_name,
+                registry_name=registry_name,
+                body=container_resource,
+            )
+            if registry_name
+            else container_operation.create_or_update(
+                name=name,
+                resource_group_name=resource_group_name,
+                workspace_name=workspace_name,
+                body=container_resource,
+            )
+        )
+
+
+def _resolve_label_to_asset(
+    assetOperations: Union[
+        "DataOperations",
+        "ComponentOperations",
+        "EnvironmentOperations",
+        "ModelOperations",
+        "IndexOperations",
+    ],
+    name: str,
+    label: str,
+) -> Asset:
+    """Returns the asset referred to by the given label.
+
+    Throws if label does not refer to a version of the named asset
+
+    :param assetOperations: The operations class used to retrieve the asset
+    :type assetOperations:
+        Union["DataOperations", "ComponentOperations", "EnvironmentOperations", "ModelOperations", "IndexOperations"]
+    :param name: The name of the asset
+    :type name: str
+    :param label: The label to resolve
+    :type label: str
+    :return: The requested asset
+    :rtype: Asset
+    """
+
+    resolver = assetOperations._managed_label_resolver.get(label, None)
+    if not resolver:
+        scope = "registry" if assetOperations._registry_name else "workspace"
+        msg = "Asset {} with version label {} does not exist in {}."
+        raise ValidationException(
+            message=msg.format(name, label, scope),
+            no_personal_data_message=msg.format("[name]", "[label]", "[scope]"),
+            target=ErrorTarget.ASSET,
+            error_type=ValidationErrorType.RESOURCE_NOT_FOUND,
+        )
+    return resolver(name)
+
+
+def _check_or_modify_auto_delete_setting(
+    autoDeleteSetting: Union[Dict, "AutoDeleteSetting"],
+):
+    if autoDeleteSetting is not None:
+        if hasattr(autoDeleteSetting, "condition"):
+            condition = getattr(autoDeleteSetting, "condition")
+            condition = snake_to_camel(condition)
+            setattr(autoDeleteSetting, "condition", condition)
+        elif "condition" in autoDeleteSetting:
+            autoDeleteSetting["condition"] = snake_to_camel(autoDeleteSetting["condition"])
+
+
+def _validate_workspace_managed_datastore(path: Optional[Union[str, PathLike]]) -> Optional[Union[str, PathLike]]:
+    # block cumtomer specified path on managed datastore
+    if path.startswith(WORKSPACE_MANAGED_DATASTORE_WITH_SLASH) or path == WORKSPACE_MANAGED_DATASTORE:
+        path = path.rstrip("/")
+
+        if path != WORKSPACE_MANAGED_DATASTORE:
+            raise AssetPathException(
+                message=INVALID_MANAGED_DATASTORE_PATH_ERROR_NO_PERSONAL_DATA,
+                tartget=ErrorTarget.DATA,
+                no_personal_data_message=INVALID_MANAGED_DATASTORE_PATH_ERROR_NO_PERSONAL_DATA,
+                error_category=ErrorCategory.USER_ERROR,
+            )
+
+        return path + "/paths"
+    return path
+
+
+def _validate_auto_delete_setting_in_data_output(
+    auto_delete_setting: Optional[Union[Dict, "AutoDeleteSetting"]]
+) -> None:
+    # avoid specifying auto_delete_setting in job output now
+    if auto_delete_setting:
+        raise ValidationException(
+            message=AUTO_DELETE_SETTING_NOT_ALLOWED_ERROR_NO_PERSONAL_DATA,
+            tartget=ErrorTarget.DATA,
+            no_personal_data_message=AUTO_DELETE_SETTING_NOT_ALLOWED_ERROR_NO_PERSONAL_DATA,
+            error_category=ErrorCategory.USER_ERROR,
+        )
+
+
+class FileUploadProgressBar(tqdm):
+    def __init__(self, msg: Optional[str] = None):
+        warnings.simplefilter("ignore", category=TqdmWarning)
+        is_windows = system() == "Windows"  # Default unicode progress bar doesn't display well on Windows
+        super().__init__(unit="B", unit_scale=True, desc=msg, ascii=is_windows)
+
+    def update_to(self, response):
+        current = response.context["upload_stream_current"]
+        self.total = response.context["data_stream_total"]
+        if current:
+            self.update(current - self.n)
+
+
+class DirectoryUploadProgressBar(tqdm):
+    def __init__(self, dir_size: int, msg: Optional[str] = None):
+        super().__init__(unit="B", unit_scale=True, desc=msg, colour="green")
+        self.total = dir_size
+        self.completed = 0
+
+    def update_to(self, response):
+        current = None
+        if response.context["upload_stream_current"]:
+            current = response.context["upload_stream_current"] + self.completed
+            self.completed = current
+        if current:
+            self.update(current - self.n)
+
+
+def get_storage_info_for_non_registry_asset(
+    service_client, workspace_name: str, name: str, version: str, resource_group: str
+) -> Dict[str, str]:
+    """Get SAS uri and blob uri for non-registry asset. Note that this function won't return the same
+    SAS uri and blob uri for the same asset. It will return a new SAS uri and blob uri every time it is called.
+    :param service_client: Service client
+    :type service_client: AzureMachineLearningWorkspaces
+    :param workspace_name: The workspace name
+    :type workspace_name: str
+    :param name: Asset name
+    :type name: str
+    :param version: Asset version
+    :type version: str
+    :param resource_group: Resource group
+    :type resource_group: str
+    :return: The sas_uri and blob_uri
+    :rtype: Dict[str, str]
+    """
+    request_body = PendingUploadRequestDto(pending_upload_type="TemporaryBlobReference")
+    response = service_client.code_versions.create_or_get_start_pending_upload(
+        resource_group_name=resource_group,
+        workspace_name=workspace_name,
+        name=name,
+        version=version,
+        body=request_body,
+    )
+
+    sas_info = {
+        "sas_uri": response.blob_reference_for_consumption.credential.sas_uri,
+        "blob_uri": response.blob_reference_for_consumption.blob_uri,
+    }
+
+    return sas_info
+
+
+def _get_existing_asset_name_and_version(existing_asset):
+    import re
+
+    regex = r"/codes/([^/]+)/versions/([^/]+)"
+
+    arm_id = existing_asset.id
+    match = re.search(regex, arm_id)
+    name = match.group(1)
+    version = match.group(2)
+
+    return name, version
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_azureml_polling.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_azureml_polling.py
new file mode 100644
index 00000000..fc148426
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_azureml_polling.py
@@ -0,0 +1,48 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+
+import logging
+from concurrent.futures import Future
+from time import time
+from typing import Optional, Union
+
+from azure.ai.ml.constants._common import LROConfigurations
+from azure.core.polling import LROPoller
+from azure.mgmt.core.polling.arm_polling import ARMPolling
+
+module_logger = logging.getLogger(__name__)
+
+
+class AzureMLPolling(ARMPolling):
+    """A polling class for azure machine learning."""
+
+    def update_status(self):
+        """Update the current status of the LRO."""
+        super().update_status()
+        print(".", end="", flush=True)
+
+
+def polling_wait(
+    poller: Union[LROPoller, Future],
+    message: Optional[str] = None,
+    start_time: Optional[float] = None,
+) -> None:
+    """Print out status while polling and time of operation once completed.
+
+    :param poller: An poller which will return status update via function done().
+    :type poller: Union[LROPoller, concurrent.futures.Future]
+    :param message: Message to print out before starting operation write-out.
+    :type message: Optional[str]
+    :param start_time: Start time of operation.
+    :type start_time: Optional[float]
+    """
+    module_logger.info("%s", message)
+    poller.result(timeout=LROConfigurations.POLLING_TIMEOUT)
+    module_logger.info("Done.")
+
+    if start_time:
+        end_time = time()
+        duration = divmod(int(round(end_time - start_time)), 60)
+        module_logger.info("(%sm %ss)\n", duration[0], duration[1])
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_cache_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_cache_utils.py
new file mode 100644
index 00000000..a9947933
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_cache_utils.py
@@ -0,0 +1,437 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import hashlib
+import logging
+import os.path
+import threading
+import time
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+from azure.ai.ml._utils._asset_utils import get_object_hash
+from azure.ai.ml._utils.utils import (
+    get_versioned_base_directory_for_cache,
+    is_concurrent_component_registration_enabled,
+    is_on_disk_cache_enabled,
+    is_private_preview_enabled,
+    write_to_shared_file,
+)
+from azure.ai.ml.constants._common import (
+    AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS,
+    AzureMLResourceType,
+    DefaultOpenEncoding,
+)
+from azure.ai.ml.entities import Component
+from azure.ai.ml.entities._builders import BaseNode
+from azure.ai.ml.entities._component.code import ComponentCodeMixin
+from azure.ai.ml.operations._operation_orchestrator import _AssetResolver
+
+logger = logging.getLogger(__name__)
+
+_ANONYMOUS_HASH_PREFIX = "anonymous-component-"
+_YAML_SOURCE_PREFIX = "yaml-source-"
+_CODE_INVOLVED_PREFIX = "code-involved-"
+EXPIRE_TIME_IN_SECONDS = 60 * 60 * 24 * 7  # 7 days
+
+_node_resolution_lock = defaultdict(threading.Lock)
+
+
+@dataclass
+class _CacheContent:
+    component_ref: Component
+    # in-memory hash assume that the code folders are not changed during the run and
+    # use the hash of code path instead of code content to simplify the calculation
+    in_memory_hash: str
+    # on-disk hash will be calculated base on code content if applicable,
+    # so it will work even if the code folders are changed among runs
+    on_disk_hash: Optional[str] = None
+    arm_id: Optional[str] = None
+
+    def update_on_disk_hash(self):
+        self.on_disk_hash = CachedNodeResolver.calc_on_disk_hash_for_component(self.component_ref, self.in_memory_hash)
+
+
+class CachedNodeResolver(object):
+    """Class to resolve component in nodes with cached component resolution results.
+
+    This class is thread-safe if:
+    1) self._resolve_nodes is not called concurrently. We guarantee this with a lock in self.resolve_nodes.
+        a) self._resolve_nodes won't be called recursively as all nodes will be skipped on
+          calling self.register_node_for_lazy_resolution.
+        b) it can't be called concurrently as node resolution involves filling back and will change the
+          state of nodes, e.g., hash of its inner component.
+    2) self._resolve_component is only called concurrently on independent components
+        a) we have used an in-memory component hash to deduplicate components to resolve first;
+        b) dependent components have been resolved before registered as nodes are registered & resolved
+          layer by layer;
+        c) dependent code will never be an instance, so it won't cause cache hit issue described in d;
+        d) resolution of potential shared dependencies (1 instance used in 2 components) other than components
+          are thread-safe as they do not involve further dependency resolution. However, it's still a good practice to
+          resolve them before calling self.register_node_for_lazy_resolution as it will impact cache hit rate.
+          For example, if:
+          node1.component, node2.component = Component(environment=env1, ...), Component(environment=env1, ...)
+          root
+           |        \
+          subgraph  node2
+            |
+          node1
+          when registering node1, its component will be:
+          {
+              "name": "component1",
+              "environment": {
+                  ...
+              }
+              ...
+          }
+          Its in-memory hash will be `hash_a` on registration.
+          Then when registering node2, the component will be:
+          {
+              "name": "component1",
+              "environment": "/subscriptions/.../environments/...",
+              ...
+          }
+          Its in-memory hash will be `hash_b`, which will be a cache miss.
+    """
+
+    def __init__(
+        self,
+        resolver: Callable[[Union[Component, str]], str],
+        client_key: str,
+    ):
+        self._resolver = resolver
+        self._cache: Dict[str, _CacheContent] = {}
+        self._nodes_to_resolve: List[BaseNode] = []
+
+        hash_obj = hashlib.sha256()
+        hash_obj.update(client_key.encode("utf-8"))
+        self._client_hash = hash_obj.hexdigest()
+        # the same client share 1 lock
+        self._lock = _node_resolution_lock[self._client_hash]
+
+    @staticmethod
+    def _get_component_registration_max_workers() -> int:
+        """Get the max workers for component registration.
+
+        Before Python 3.8, the default max_worker is the number of processors multiplied by 5.
+        It may send a large number of the uploading snapshot requests that will occur remote refuses requests.
+        In order to avoid retrying the upload requests, max_worker will use the default value in Python 3.8,
+        min(32, os.cpu_count + 4).
+
+        1 risk is that, asset_utils will create a new thread pool to upload files in subprocesses, which may cause
+        the number of threads exceed the max_worker.
+
+        :return: The number of workers to use for component registration
+        :rtype: int
+        """
+        default_max_workers = min(32, (os.cpu_count() or 1) + 4)
+        try:
+            max_workers = int(os.environ.get(AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS, default_max_workers))
+        except ValueError:
+            logger.info(
+                "Environment variable %s with value %s set but failed to parse. "
+                "Use the default max_worker %s as registration thread pool max_worker."
+                "Please reset the value to an integer.",
+                AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS,
+                os.environ.get(AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS),
+                default_max_workers,
+            )
+            max_workers = default_max_workers
+        return max_workers
+
+    @staticmethod
+    def _get_in_memory_hash_for_component(component: Component) -> str:
+        """Get a hash for a component.
+
+        This function assumes that there is no change in code folder among hash calculations, which is true during
+        resolution of 1 root pipeline component/job.
+
+        :param component: The component
+        :type component: Component
+        :return: The hash of the component
+        :rtype: str
+        """
+        if not isinstance(component, Component):
+            # this shouldn't happen; handle it in case invalid call is made outside this class
+            raise ValueError(f"Component {component} is not a Component object.")
+
+        # For components with code, its code will be an absolute path before uploaded to blob,
+        # so we can use a mixture of its anonymous hash and its source path as its hash, in case
+        # there are 2 components with same code but different ignore files
+        # Here we can check if the component has a source path instead of check if it has code, as
+        # there is no harm to add a source path to the hash even if the component doesn't have code
+        # Note that here we assume that the content of code folder won't change during the submission
+        if component._source_path:  # pylint: disable=protected-access
+            object_hash = hashlib.sha256()
+            object_hash.update(component._get_anonymous_hash().encode("utf-8"))  # pylint: disable=protected-access
+            object_hash.update(component._source_path.encode("utf-8"))  # pylint: disable=protected-access
+            return _YAML_SOURCE_PREFIX + object_hash.hexdigest()
+        # For components without code, like pipeline component, their dependencies have already
+        # been resolved before calling this function, so we can use their anonymous hash directly
+        return _ANONYMOUS_HASH_PREFIX + component._get_anonymous_hash()  # pylint: disable=protected-access
+
+    @staticmethod
+    def calc_on_disk_hash_for_component(component: Component, in_memory_hash: str) -> str:
+        """Get a hash for a component.
+
+        This function will calculate the hash based on the component's code folder if the component has code, so it's
+        unique even if code folder is changed.
+
+        :param component: The component to hash
+        :type component: Component
+        :param in_memory_hash: :attr:`_CacheNodeResolver.in_memory_hash`
+        :type in_memory_hash: str
+        :return: The hash of the component
+        :rtype: str
+        """
+        if not isinstance(component, Component):
+            # this shouldn't happen; handle it in case invalid call is made outside this class
+            raise ValueError(f"Component {component} is not a Component object.")
+
+        # TODO: calculate hash without resolving additional includes (copy code to temp folder)
+        # note that it's still thread-safe with current implementation, as only read operations are
+        # done on the original code folder
+        if not (
+            isinstance(component, ComponentCodeMixin)
+            and component._with_local_code()  # pylint: disable=protected-access
+        ):
+            return in_memory_hash
+
+        with component._build_code() as code:  # pylint: disable=protected-access
+            if hasattr(code, "_upload_hash"):
+                content_hash = code._upload_hash  # pylint: disable=protected-access
+            else:
+                code_path = code.path if os.path.isabs(code.path) else os.path.join(code.base_path, code.path)
+                if os.path.exists(code_path):
+                    content_hash = get_object_hash(code_path)
+                else:
+                    # this will be gated by schema validation, so it shouldn't happen except for mock tests
+                    return in_memory_hash
+
+            object_hash = hashlib.sha256()
+            object_hash.update(in_memory_hash.encode("utf-8"))
+
+            object_hash.update(content_hash.encode("utf-8"))
+            return _CODE_INVOLVED_PREFIX + object_hash.hexdigest()
+
+    @property
+    def _on_disk_cache_dir(self) -> Path:
+        """Get the base path for on disk cache.
+
+        :return: The base path for the on disk cache
+        :rtype: Path
+        """
+        return get_versioned_base_directory_for_cache().joinpath(
+            "components",
+            self._client_hash,
+        )
+
+    def _get_on_disk_cache_path(self, on_disk_hash: str) -> Path:
+        """Get the on disk cache path for a component.
+
+        :param on_disk_hash: The hash of the component
+        :type on_disk_hash: str
+        :return: The path to the disk cache
+        :rtype: Path
+        """
+        return self._on_disk_cache_dir.joinpath(on_disk_hash)
+
+    def _load_from_on_disk_cache(self, on_disk_hash: str) -> Optional[str]:
+        """Load component arm id from on disk cache.
+
+        :param on_disk_hash: The hash of the component
+        :type on_disk_hash: str
+        :return: The cached component arm id if reading was successful, None otherwise
+        :rtype: Optional[str]
+        """
+        # on-disk cache will expire in a new SDK version
+        on_disk_cache_path = self._get_on_disk_cache_path(on_disk_hash)
+        if on_disk_cache_path.is_file() and time.time() - on_disk_cache_path.stat().st_ctime < EXPIRE_TIME_IN_SECONDS:
+            try:
+                return on_disk_cache_path.read_text(encoding=DefaultOpenEncoding.READ).strip()
+            except (OSError, PermissionError) as e:
+                logger.warning(
+                    "Failed to read on-disk cache for component due to %s. "
+                    "Please check if the file %s is in use or current user doesn't have the permission.",
+                    type(e).__name__,
+                    on_disk_cache_path.as_posix(),
+                )
+        return None
+
+    def _save_to_on_disk_cache(self, on_disk_hash: str, arm_id: str) -> None:
+        """Save component arm id to on disk cache.
+
+        :param on_disk_hash: The on disk hash of the component
+        :type on_disk_hash: str
+        :param arm_id: The component ARM ID
+        :type arm_id: str
+        """
+        # this shouldn't happen in real case, but in case of current mock tests and potential future changes
+        if not isinstance(arm_id, str):
+            return
+        on_disk_cache_path = self._get_on_disk_cache_path(on_disk_hash)
+        on_disk_cache_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            write_to_shared_file(on_disk_cache_path, arm_id)
+        except PermissionError:
+            logger.warning(
+                "Failed to save on-disk cache for component due to permission error. "
+                "Please check if the file %s is in use or current user doesn't have the permission.",
+                on_disk_cache_path.as_posix(),
+            )
+
+    def _resolve_cache_contents(self, cache_contents_to_resolve: List[_CacheContent], resolver: _AssetResolver):
+        """Resolve all components to resolve and save the results in cache.
+
+        :param cache_contents_to_resolve: The cache contents to resolve
+        :type cache_contents_to_resolve: List[_CacheContent]
+        :param resolver: The resolver function
+        :type resolver: _AssetResolver
+        """
+
+        def _map_func(_cache_content: _CacheContent):
+            _cache_content.arm_id = resolver(_cache_content.component_ref, azureml_type=AzureMLResourceType.COMPONENT)
+            if is_on_disk_cache_enabled() and is_private_preview_enabled():
+                self._save_to_on_disk_cache(_cache_content.on_disk_hash, _cache_content.arm_id)
+
+        if (
+            len(cache_contents_to_resolve) > 1
+            and is_concurrent_component_registration_enabled()
+            and is_private_preview_enabled()
+        ):
+            # given deduplication has already been done, we can safely assume that there is no
+            # conflict in concurrent local cache access
+            with ThreadPoolExecutor(max_workers=self._get_component_registration_max_workers()) as executor:
+                list(executor.map(_map_func, cache_contents_to_resolve))
+        else:
+            list(map(_map_func, cache_contents_to_resolve))
+
+    def _prepare_items_to_resolve(self) -> Tuple[Dict[str, List[BaseNode]], List[_CacheContent]]:
+        """Pop all nodes in self._nodes_to_resolve to prepare cache contents to resolve and nodes to resolve. Nodes in
+        self._nodes_to_resolve will be grouped by component hash and saved to a dict of list. Distinct dependent
+        components not in current cache will be saved to a list.
+
+        :return: a tuple of (dict of nodes to resolve, list of cache contents to resolve)
+        :rtype: Tuple[Dict[str, List[BaseNode]],  List[_CacheContent]]
+        """
+        _components = list(map(lambda x: x._component, self._nodes_to_resolve))  # pylint: disable=protected-access
+        # we can do concurrent component in-memory hash calculation here
+        in_memory_component_hashes = map(self._get_in_memory_hash_for_component, _components)
+
+        dict_of_nodes_to_resolve = defaultdict(list)
+        cache_contents_to_resolve: List[_CacheContent] = []
+        for node, component_hash in zip(self._nodes_to_resolve, in_memory_component_hashes):
+            dict_of_nodes_to_resolve[component_hash].append(node)
+            if component_hash not in self._cache:
+                cache_content = _CacheContent(
+                    component_ref=node._component,  # pylint: disable=protected-access
+                    in_memory_hash=component_hash,
+                )
+                self._cache[component_hash] = cache_content
+                cache_contents_to_resolve.append(cache_content)
+        self._nodes_to_resolve.clear()
+        return dict_of_nodes_to_resolve, cache_contents_to_resolve
+
+    def _resolve_cache_contents_from_disk(self, cache_contents_to_resolve: List[_CacheContent]) -> List[_CacheContent]:
+        """Check on-disk cache to resolve cache contents in cache_contents_to_resolve and return unresolved cache
+        contents.
+
+        :param cache_contents_to_resolve: The cache contents to resolve
+        :type cache_contents_to_resolve: List[_CacheContent]
+        :return: Unresolved cache contents
+        :rtype: List[_CacheContent]
+        """
+        # Note that we should recalculate the hash based on code for local cache, as
+        # we can't assume that the code folder won't change among dependency
+        # On-disk hash calculation can be slow as it involved data copying and artifact downloading.
+        # It is thread-safe given:
+        # 1. artifact downloading is thread-safe as we have a lock in ArtifactCache
+        # 2. data copying is thread-safe as there is only read operation on source folder
+        #    and target folder is unique for each thread
+        if (
+            len(cache_contents_to_resolve) > 1
+            and is_concurrent_component_registration_enabled()
+            and is_private_preview_enabled()
+        ):
+            with ThreadPoolExecutor(max_workers=self._get_component_registration_max_workers()) as executor:
+                executor.map(_CacheContent.update_on_disk_hash, cache_contents_to_resolve)
+        else:
+            list(map(_CacheContent.update_on_disk_hash, cache_contents_to_resolve))
+
+        left_cache_contents_to_resolve = []
+        # need to deduplicate disk hash first if concurrent resolution is enabled
+        for cache_content in cache_contents_to_resolve:
+            cache_content.arm_id = self._load_from_on_disk_cache(cache_content.on_disk_hash)
+            if not cache_content.arm_id:
+                left_cache_contents_to_resolve.append(cache_content)
+
+        return left_cache_contents_to_resolve
+
+    def _fill_back_component_to_nodes(self, dict_of_nodes_to_resolve: Dict[str, List[BaseNode]]):
+        """Fill back resolved component to nodes.
+
+        :param dict_of_nodes_to_resolve: The nodes to resolve
+        :type dict_of_nodes_to_resolve: Dict[str, List[BaseNode]]
+        """
+        for component_hash, nodes in dict_of_nodes_to_resolve.items():
+            cache_content = self._cache[component_hash]
+            for node in nodes:
+                node._component = cache_content.arm_id  # pylint: disable=protected-access
+
+    def _resolve_nodes(self):
+        """Processing logic of self.resolve_nodes.
+
+        Should not be called in subgraph creation.
+        """
+        dict_of_nodes_to_resolve, cache_contents_to_resolve = self._prepare_items_to_resolve()
+
+        if is_on_disk_cache_enabled() and is_private_preview_enabled():
+            cache_contents_to_resolve = self._resolve_cache_contents_from_disk(cache_contents_to_resolve)
+
+        self._resolve_cache_contents(cache_contents_to_resolve, resolver=self._resolver)
+
+        self._fill_back_component_to_nodes(dict_of_nodes_to_resolve)
+
+    def register_node_for_lazy_resolution(self, node: BaseNode):
+        """Register a node with its component to resolve.
+
+        :param node: The node
+        :type node: BaseNode
+        """
+        component = node._component  # pylint: disable=protected-access
+
+        # directly resolve node and skip registration if the resolution involves no remote call
+        # so that all node will be skipped when resolving a subgraph recursively
+        if isinstance(component, str):
+            node._component = self._resolver(  # pylint: disable=protected-access
+                component, azureml_type=AzureMLResourceType.COMPONENT
+            )
+            return
+        if component.id is not None:
+            node._component = component.id  # pylint: disable=protected-access
+            return
+
+        self._nodes_to_resolve.append(node)
+
+    def resolve_nodes(self):
+        """Resolve all dependent components with resolver and set resolved component arm id back to newly registered
+        nodes.
+
+        Registered nodes will be cleared after resolution.
+        """
+        if not self._nodes_to_resolve:
+            return
+
+        # Lock here as node resolution involves filling back and will change the
+        # state of nodes, e.g. hash of its inner component.
+        # This will happen only on concurrent external calls; In 1 external call, all nodes in
+        # subgraph will be skipped on register_node_for_lazy_resolution when resolving subgraph
+        self._lock.acquire()
+        try:
+            self._resolve_nodes()
+        finally:
+            # release lock even if exception happens
+            self._lock.release()
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_data_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_data_utils.py
new file mode 100644
index 00000000..bde91d34
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_data_utils.py
@@ -0,0 +1,82 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import io
+import json
+import logging
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Dict, Union
+from urllib.parse import urljoin, urlparse
+
+import yaml
+from jsonschema import Draft7Validator, ValidationError
+from jsonschema.exceptions import best_match
+
+from azure.ai.ml._artifacts._artifact_utilities import get_datastore_info, get_storage_client
+from azure.ai.ml._artifacts._constants import INVALID_MLTABLE_METADATA_SCHEMA_ERROR, INVALID_MLTABLE_METADATA_SCHEMA_MSG
+from azure.ai.ml.constants._common import DefaultOpenEncoding
+from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+from azure.ai.ml.operations._datastore_operations import DatastoreOperations
+
+from ._http_utils import HttpPipeline
+from ._storage_utils import AzureMLDatastorePathUri
+from .utils import load_yaml
+
+module_logger = logging.getLogger(__name__)
+
+
+def download_mltable_metadata_schema(mltable_schema_url: str, requests_pipeline: HttpPipeline):
+    response = requests_pipeline.get(mltable_schema_url)
+    return response.json()
+
+
+def read_local_mltable_metadata_contents(*, path: str) -> Dict:
+    metadata_path = str(Path(path, "MLTable"))
+    return load_yaml(metadata_path)
+
+
+def read_remote_mltable_metadata_contents(
+    *,
+    base_uri: str,
+    datastore_operations: DatastoreOperations,
+    requests_pipeline: HttpPipeline,
+) -> Union[Dict, None]:
+    scheme = urlparse(base_uri).scheme
+    if scheme == "https":
+        response = requests_pipeline.get(urljoin(base_uri, "MLTable"))
+        yaml_file = io.BytesIO(response.content)
+        return yaml.safe_load(yaml_file)
+    if scheme == "azureml":
+        datastore_path_uri = AzureMLDatastorePathUri(base_uri)
+        datastore_info = get_datastore_info(datastore_operations, datastore_path_uri.datastore)
+        storage_client = get_storage_client(**datastore_info)
+        with TemporaryDirectory() as tmp_dir:
+            starts_with = datastore_path_uri.path.rstrip("/")
+            storage_client.download(f"{starts_with}/MLTable", tmp_dir)
+            downloaded_mltable_path = Path(tmp_dir, "MLTable")
+            with open(downloaded_mltable_path, "r", encoding=DefaultOpenEncoding.READ) as f:
+                return yaml.safe_load(f)
+    return None
+
+
+def validate_mltable_metadata(*, mltable_metadata_dict: Dict, mltable_schema: Dict):
+    # use json-schema to validate dict
+    error: Union[ValidationError, None] = best_match(Draft7Validator(mltable_schema).iter_errors(mltable_metadata_dict))
+    if error:
+        err_path = ".".join(error.path)
+        err_path = f"{err_path}: " if err_path != "" else ""
+        msg = INVALID_MLTABLE_METADATA_SCHEMA_ERROR.format(
+            jsonSchemaErrorPath=err_path,
+            jsonSchemaMessage=error.message,
+            invalidMLTableMsg=INVALID_MLTABLE_METADATA_SCHEMA_MSG,
+            invalidSchemaSnippet=json.dumps(error.schema, indent=2),
+        )
+        raise ValidationException(
+            message=msg,
+            no_personal_data_message=INVALID_MLTABLE_METADATA_SCHEMA_MSG,
+            error_type=ValidationErrorType.INVALID_VALUE,
+            target=ErrorTarget.DATA,
+            error_category=ErrorCategory.USER_ERROR,
+        )
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_endpoint_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_endpoint_utils.py
new file mode 100644
index 00000000..b8bab283
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_endpoint_utils.py
@@ -0,0 +1,229 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+# pylint: disable=protected-access
+
+import ast
+import concurrent.futures
+import logging
+import time
+from concurrent.futures import Future
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Union
+
+from azure.ai.ml._restclient.v2020_09_01_dataplanepreview.models import DataVersion, UriFileJobOutput
+from azure.ai.ml._utils._arm_id_utils import is_ARM_id_for_resource, is_registry_id_for_resource
+from azure.ai.ml._utils._logger_utils import initialize_logger_info
+from azure.ai.ml.constants._common import ARM_ID_PREFIX, AzureMLResourceType, DefaultOpenEncoding, LROConfigurations
+from azure.ai.ml.entities import BatchDeployment
+from azure.ai.ml.entities._assets._artifacts.code import Code
+from azure.ai.ml.entities._deployment.deployment import Deployment
+from azure.ai.ml.entities._deployment.model_batch_deployment import ModelBatchDeployment
+from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, MlException, ValidationErrorType, ValidationException
+from azure.ai.ml.operations._operation_orchestrator import OperationOrchestrator
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceExistsError,
+    ResourceNotFoundError,
+    ServiceRequestTimeoutError,
+    map_error,
+)
+from azure.core.polling import LROPoller
+from azure.core.rest import HttpResponse
+from azure.mgmt.core.exceptions import ARMErrorFormat
+
+module_logger = logging.getLogger(__name__)
+initialize_logger_info(module_logger, terminator="")
+
+
+def get_duration(start_time: float) -> None:
+    """Calculates the duration of the Long running operation took to finish.
+
+    :param start_time: Start time
+    :type start_time: float
+    """
+    end_time = time.time()
+    duration = divmod(int(round(end_time - start_time)), 60)
+    module_logger.warning("(%sm %ss)\n", duration[0], duration[1])
+
+
+def polling_wait(
+    poller: Union[LROPoller, Future],
+    message: Optional[str] = None,
+    start_time: Optional[float] = None,
+    is_local=False,
+    timeout=LROConfigurations.POLLING_TIMEOUT,
+) -> Any:
+    """Print out status while polling and time of operation once completed.
+
+    :param poller: An poller which will return status update via function done().
+    :type poller: Union[LROPoller, concurrent.futures.Future]
+    :param (str, optional) message: Message to print out before starting operation write-out.
+    :param (float, optional) start_time: Start time of operation.
+    :param (bool, optional) is_local: If poller is for a local endpoint, so the timeout is removed.
+    :param (int, optional) timeout: New value to overwrite the default timeout.
+    """
+    module_logger.warning("%s", message)
+    if is_local:
+        # We removed timeout on local endpoints in case it takes a long time
+        # to pull image or install conda env.
+
+        # We want user to be able to see that.
+
+        while not poller.done():
+            module_logger.warning(".")
+            time.sleep(LROConfigurations.SLEEP_TIME)
+    else:
+        poller.result(timeout=timeout)
+
+    if poller.done():
+        module_logger.warning("Done ")
+    else:
+        module_logger.warning("Timeout waiting for long running operation")
+
+    if start_time:
+        get_duration(start_time)
+
+
+def local_endpoint_polling_wrapper(func: Callable, message: str, **kwargs) -> Any:
+    """Wrapper for polling local endpoint operations.
+
+    :param func: Name of the endpoint.
+    :type func: Callable
+    :param message: Message to print out before starting operation write-out.
+    :type message: str
+    :return: The type returned by Func
+    """
+    pool = concurrent.futures.ThreadPoolExecutor()
+    start_time = time.time()
+    event = pool.submit(func, **kwargs)
+    polling_wait(poller=event, start_time=start_time, message=message, is_local=True)
+    return event.result()
+
+
+def validate_response(response: HttpResponse) -> None:
+    """Validates the response of POST requests, throws on error.
+
+    :param HttpResponse response: the response of a POST requests
+    :raises Exception: Raised when response is not json serializable
+    :raises HttpResponseError: Raised when the response signals that an error occurred
+    """
+    r_json = {}
+
+    if response.status_code not in [200, 201]:
+        # We need to check for an empty response body or catch the exception raised.
+        # It is possible the server responded with a 204 No Content response, and json parsing fails.
+        if response.status_code != 204:
+            try:
+                r_json = response.json()
+            except ValueError as e:
+                # exception is not in the json format
+                msg = response.content.decode("utf-8")
+                raise MlException(message=msg, no_personal_data_message=msg) from e
+        failure_msg = r_json.get("error", {}).get("message", response)
+        error_map = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            408: ServiceRequestTimeoutError,
+            409: ResourceExistsError,
+            424: HttpResponseError,
+        }
+        map_error(status_code=response.status_code, response=response, error_map=error_map)
+        raise HttpResponseError(response=response, message=failure_msg, error_format=ARMErrorFormat)
+
+
+def upload_dependencies(deployment: Deployment, orchestrators: OperationOrchestrator) -> None:
+    """Upload code, dependency, model dependencies. For BatchDeployment only register compute.
+
+    :param Deployment deployment: Endpoint deployment object.
+    :param OperationOrchestrator orchestrators: Operation Orchestrator.
+    """
+
+    module_logger.debug("Uploading the dependencies for deployment %s", deployment.name)
+
+    # Create a code asset if code is not already an ARM ID
+    if (
+        deployment.code_configuration
+        and not is_ARM_id_for_resource(deployment.code_configuration.code, AzureMLResourceType.CODE)
+        and not is_registry_id_for_resource(deployment.code_configuration.code)
+    ):
+        if deployment.code_configuration.code.startswith(ARM_ID_PREFIX):
+            deployment.code_configuration.code = orchestrators.get_asset_arm_id(
+                deployment.code_configuration.code[len(ARM_ID_PREFIX) :],
+                azureml_type=AzureMLResourceType.CODE,
+            )
+        else:
+            deployment.code_configuration.code = orchestrators.get_asset_arm_id(
+                Code(base_path=deployment._base_path, path=deployment.code_configuration.code),
+                azureml_type=AzureMLResourceType.CODE,
+            )
+
+    if not is_registry_id_for_resource(deployment.environment):
+        deployment.environment = (
+            orchestrators.get_asset_arm_id(deployment.environment, azureml_type=AzureMLResourceType.ENVIRONMENT)
+            if deployment.environment
+            else None
+        )
+    if not is_registry_id_for_resource(deployment.model):
+        deployment.model = (
+            orchestrators.get_asset_arm_id(deployment.model, azureml_type=AzureMLResourceType.MODEL)
+            if deployment.model
+            else None
+        )
+    if isinstance(deployment, (BatchDeployment, ModelBatchDeployment)) and deployment.compute:
+        deployment.compute = orchestrators.get_asset_arm_id(
+            deployment.compute, azureml_type=AzureMLResourceType.COMPUTE
+        )
+
+
+def validate_scoring_script(deployment):
+    score_script_path = Path(deployment.base_path).joinpath(
+        deployment.code_configuration.code, deployment.scoring_script
+    )
+    try:
+        with open(score_script_path, "r", encoding=DefaultOpenEncoding.READ) as script:
+            contents = script.read()
+            try:
+                ast.parse(contents, score_script_path)
+            except SyntaxError as err:
+                err.filename = err.filename.split("/")[-1]
+                msg = (
+                    f"Failed to submit deployment {deployment.name} due to syntax errors "
+                    f"in scoring script {err.filename}.\nError on line {err.lineno}: "
+                    f"{err.text}\nIf you wish to bypass this validation use --skip-script-validation paramater."
+                )
+
+                np_msg = (
+                    "Failed to submit deployment due to syntax errors in deployment script."
+                    "\n If you wish to bypass this validation use --skip-script-validation paramater."
+                )
+                raise ValidationException(
+                    message=msg,
+                    target=(
+                        ErrorTarget.BATCH_DEPLOYMENT
+                        if isinstance(deployment, BatchDeployment)
+                        else ErrorTarget.ONLINE_DEPLOYMENT
+                    ),
+                    no_personal_data_message=np_msg,
+                    error_category=ErrorCategory.USER_ERROR,
+                    error_type=ValidationErrorType.CANNOT_PARSE,
+                ) from err
+    except OSError as err:
+        raise MlException(
+            message=f"Failed to open scoring script {err.filename}.",
+            no_personal_data_message="Failed to open scoring script.",
+        ) from err
+
+
+def convert_v1_dataset_to_v2(output_data_set: DataVersion, file_name: str) -> Dict[str, Any]:
+    if file_name:
+        v2_dataset = UriFileJobOutput(
+            uri=f"azureml://datastores/{output_data_set.datastore_id}/paths/{output_data_set.path}/{file_name}"
+        ).serialize()
+    else:
+        v2_dataset = UriFileJobOutput(
+            uri=f"azureml://datastores/{output_data_set.datastore_id}/paths/{output_data_set.path}"
+        ).serialize()
+    return {"output_name": v2_dataset}
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_experimental.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_experimental.py
new file mode 100644
index 00000000..42b0bee6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_experimental.py
@@ -0,0 +1,156 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import functools
+import inspect
+import logging
+import sys
+from typing import Callable, Type, TypeVar, Union
+
+from typing_extensions import ParamSpec
+
+from azure.ai.ml.constants._common import (
+    DOCSTRING_DEFAULT_INDENTATION,
+    DOCSTRING_TEMPLATE,
+    EXPERIMENTAL_CLASS_MESSAGE,
+    EXPERIMENTAL_LINK_MESSAGE,
+    EXPERIMENTAL_METHOD_MESSAGE,
+)
+
+_warning_cache = set()
+module_logger = logging.getLogger(__name__)
+
+TExperimental = TypeVar("TExperimental", bound=Union[Type, Callable])
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def experimental(wrapped: TExperimental) -> TExperimental:
+    """Add experimental tag to a class or a method.
+
+    :param wrapped: Either a Class or Function to mark as experimental
+    :type wrapped: TExperimental
+    :return: The wrapped class or method
+    :rtype: TExperimental
+    """
+    if inspect.isclass(wrapped):
+        return _add_class_docstring(wrapped)
+    if inspect.isfunction(wrapped):
+        return _add_method_docstring(wrapped)
+    return wrapped
+
+
+def _add_class_docstring(cls: Type[T]) -> Type[T]:
+    """Add experimental tag to the class doc string.
+
+    :return: The updated class
+    :rtype: Type[T]
+    """
+
+    P2 = ParamSpec("P2")
+
+    def _add_class_warning(func: Callable[P2, None]) -> Callable[P2, None]:
+        """Add warning message for class __init__.
+
+        :param func: The original __init__ function
+        :type func: Callable[P2, None]
+        :return: Updated __init__
+        :rtype: Callable[P2, None]
+        """
+
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            message = "Class {0}: {1} {2}".format(cls.__name__, EXPERIMENTAL_CLASS_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+            if not _should_skip_warning() and not _is_warning_cached(message):
+                module_logger.warning(message)
+            return func(*args, **kwargs)
+
+        return wrapped
+
+    doc_string = DOCSTRING_TEMPLATE.format(EXPERIMENTAL_CLASS_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+    if cls.__doc__:
+        cls.__doc__ = _add_note_to_docstring(cls.__doc__, doc_string)
+    else:
+        cls.__doc__ = doc_string + ">"
+    cls.__init__ = _add_class_warning(cls.__init__)
+    return cls
+
+
+def _add_method_docstring(func: Callable[P, T] = None) -> Callable[P, T]:
+    """Add experimental tag to the method doc string.
+
+    :param func: The function to update
+    :type func: Callable[P, T]
+    :return: A wrapped method marked as experimental
+    :rtype: Callable[P,T]
+    """
+    doc_string = DOCSTRING_TEMPLATE.format(EXPERIMENTAL_METHOD_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+    if func.__doc__:
+        func.__doc__ = _add_note_to_docstring(func.__doc__, doc_string)
+    else:
+        # '>' is required. Otherwise the note section can't be generated
+        func.__doc__ = doc_string + ">"
+
+    @functools.wraps(func)
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
+        message = "Method {0}: {1} {2}".format(func.__name__, EXPERIMENTAL_METHOD_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+        if not _should_skip_warning() and not _is_warning_cached(message):
+            module_logger.warning(message)
+        return func(*args, **kwargs)
+
+    return wrapped
+
+
+def _add_note_to_docstring(doc_string: str, note: str) -> str:
+    """Adds experimental note to docstring at the top and correctly indents original docstring.
+
+    :param doc_string: The docstring
+    :type doc_string: str
+    :param note: The note to add to the docstring
+    :type note: str
+    :return: Updated docstring
+    :rtype: str
+    """
+    indent = _get_indentation_size(doc_string)
+    doc_string = doc_string.rjust(len(doc_string) + indent)
+    return note + doc_string
+
+
+def _get_indentation_size(doc_string: str) -> int:
+    """Finds the minimum indentation of all non-blank lines after the first line.
+
+    :param doc_string: The docstring
+    :type doc_string: str
+    :return: Minimum number of indentation of the docstring
+    :rtype: int
+    """
+    lines = doc_string.expandtabs().splitlines()
+    indent = sys.maxsize
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped:
+            indent = min(indent, len(line) - len(stripped))
+    return indent if indent < sys.maxsize else DOCSTRING_DEFAULT_INDENTATION
+
+
+def _should_skip_warning():
+    skip_warning_msg = False
+
+    # Cases where we want to suppress the warning:
+    # 1. When converting from REST object to SDK object
+    for frame in inspect.stack():
+        if frame.function == "_from_rest_object":
+            skip_warning_msg = True
+            break
+
+    return skip_warning_msg
+
+
+def _is_warning_cached(warning_msg):
+    # use cache to make sure we only print same warning message once under same session
+    # this prevents duplicated warnings got printed when user does a loop call on a method or a class
+    if warning_msg in _warning_cache:
+        return True
+    _warning_cache.add(warning_msg)
+    return False
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_feature_store_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_feature_store_utils.py
new file mode 100644
index 00000000..8bcf4e2e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_feature_store_utils.py
@@ -0,0 +1,109 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+# pylint: disable=protected-access
+from datetime import datetime
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING, Dict, Union
+from urllib.parse import urlparse
+
+import yaml
+
+from .._artifacts._artifact_utilities import get_datastore_info, get_storage_client
+from .._restclient.v2023_10_01.operations import (  # pylint: disable = unused-import
+    FeaturesetContainersOperations,
+    FeaturesetVersionsOperations,
+    FeaturestoreEntityContainersOperations,
+    FeaturestoreEntityVersionsOperations,
+)
+from ..constants._common import DefaultOpenEncoding
+from ..exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+from ..operations._datastore_operations import DatastoreOperations
+from ._storage_utils import AzureMLDatastorePathUri
+from .utils import load_yaml
+
+if TYPE_CHECKING:
+    from azure.ai.ml.operations._feature_set_operations import FeatureSetOperations
+    from azure.ai.ml.operations._feature_store_entity_operations import FeatureStoreEntityOperations
+
+
+def read_feature_set_metadata(*, path: str) -> Dict:
+    metadata_path = str(Path(path, "FeatureSetSpec.yaml"))
+    return load_yaml(metadata_path)
+
+
+def read_remote_feature_set_spec_metadata(
+    *,
+    base_uri: str,
+    datastore_operations: DatastoreOperations,
+) -> Union[Dict, None]:
+    scheme = urlparse(base_uri).scheme
+    if scheme == "azureml":
+        datastore_path_uri = AzureMLDatastorePathUri(base_uri)
+        datastore_info = get_datastore_info(datastore_operations, datastore_path_uri.datastore)
+        storage_client = get_storage_client(**datastore_info)
+        with TemporaryDirectory() as tmp_dir:
+            starts_with = datastore_path_uri.path.rstrip("/")
+            storage_client.download(f"{starts_with}/FeatureSetSpec.yaml", tmp_dir)
+            downloaded_spec_path = Path(tmp_dir, "FeatureSetSpec.yaml")
+            with open(downloaded_spec_path, "r", encoding=DefaultOpenEncoding.READ) as f:
+                return yaml.safe_load(f)
+    return None
+
+
+def _archive_or_restore(
+    asset_operations: Union["FeatureSetOperations", "FeatureStoreEntityOperations"],
+    version_operation: Union[
+        "FeaturesetVersionsOperations",
+        "FeaturestoreEntityVersionsOperations",
+    ],
+    is_archived: bool,
+    name: str,
+    version: str,
+    **kwargs,
+) -> None:
+    resource_group_name = asset_operations._operation_scope._resource_group_name
+    workspace_name = asset_operations._workspace_name
+
+    version_resource = version_operation.get(
+        name=name,
+        version=version,
+        resource_group_name=resource_group_name,
+        workspace_name=workspace_name,
+    )
+
+    if version_resource.properties.stage == "Archived" and is_archived:
+        raise ValidationException(
+            message="Asset version is already archived: {}:{}".format(name, version),
+            no_personal_data_message="Asset version is already archived",
+            target=ErrorTarget.ASSET,
+            error_category=ErrorCategory.USER_ERROR,
+            error_type=ValidationErrorType.INVALID_VALUE,
+        )
+
+    if version_resource.properties.stage != "Archived" and not is_archived:
+        raise ValidationException(
+            message="Cannot restore non-archived asset version: {}:{}".format(name, version),
+            no_personal_data_message="Asset version is not archived",
+            target=ErrorTarget.ASSET,
+            error_category=ErrorCategory.USER_ERROR,
+            error_type=ValidationErrorType.INVALID_VALUE,
+        )
+
+    version_resource.properties.is_archived = is_archived
+    version_resource.properties.stage = "Archived" if is_archived else "Development"
+    poller = version_operation.begin_create_or_update(
+        name=name,
+        version=version,
+        resource_group_name=resource_group_name,
+        workspace_name=workspace_name,
+        body=version_resource,
+        **kwargs,
+    )
+    poller.result()
+
+
+def _datetime_to_str(datetime_obj: Union[str, datetime]):
+    return datetime_obj if isinstance(datetime_obj, str) else datetime_obj.isoformat()
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_func_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_func_utils.py
new file mode 100644
index 00000000..0e4b465a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_func_utils.py
@@ -0,0 +1,471 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import abc
+import logging
+import sys
+from contextlib import contextmanager
+from types import CodeType, FrameType, FunctionType, MethodType
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
+
+from azure.ai.ml._utils.utils import is_bytecode_optimization_enabled
+
+logger = logging.getLogger(__name__)
+
+
+class PersistentLocalsFunctionBuilder(abc.ABC):
+    errors = {
+        "not_callable": "func must be a function or a callable object",
+        "conflict_argument": "Injected param name __self conflicts with function args {args}",
+        "not_all_template_separators_used": "Not all template separators are used, "
+        "please switch to a compatible version of Python.",
+        "invalid_template": "Provided template functions are invalid in current environment, "
+        "please switch to a compatible version (3.9 e.g.) of Python "
+        "and/or check template functions.",
+    }
+    injected_param = "__self"
+
+    @classmethod
+    def make_error(cls, error_name: str, **kwargs) -> str:
+        """Make error message with error_name and kwargs.
+
+        :param error_name: A key from :attr:`~PersistentLocalsFunctionBuilder.errors`
+        :type error_name: str
+        :return: Formatted error message
+        :rtype: str
+        """
+        return cls.errors[error_name].format(**kwargs)
+
+    @abc.abstractmethod
+    def _call(self, func, _all_kwargs) -> Tuple[Any, dict]:
+        raise NotImplementedError()
+
+    def call(self, func, _all_kwargs) -> Tuple[Any, dict]:
+        """Get outputs and locals in calling func with _all_kwargs. Locals will be used to update node variable names.
+
+        :param func: The function to execute.
+        :type func: Union[FunctionType, MethodType]
+        :param _all_kwargs: All kwargs to call self.func.
+        :type _all_kwargs: typing.Dict[str, typing.Any]
+        :return: A tuple of outputs and locals.
+        :rtype: typing.Tuple[typing.Any, typing.Dict]
+        """
+        if isinstance(func, (FunctionType, MethodType)):
+            pass
+        elif hasattr(func, "__call__"):
+            func = func.__call__
+        else:
+            raise TypeError(self.make_error("not_callable"))
+
+        if self.injected_param in func.__code__.co_varnames:
+            raise ValueError(self.make_error("conflict_argument", args=list(func.__code__.co_varnames)))
+
+        return self._call(func, _all_kwargs)
+
+
+class PersistentLocalsFunctionProfilerBuilder(PersistentLocalsFunctionBuilder):
+    @staticmethod
+    @contextmanager
+    # pylint: disable-next=docstring-missing-return,docstring-missing-rtype
+    def _replace_sys_profiler(profiler: Callable[[FrameType, str, Any], None]) -> Iterable[None]:
+        """A context manager which replaces sys profiler to given profiler.
+
+        :param profiler: The profile function.
+            See https://docs.python.org/3/library/sys.html#sys.setprofile for more information
+        :type profiler: Callable[[FrameType, str, Any], None]
+        """
+        original_profiler = sys.getprofile()
+        sys.setprofile(profiler)
+        try:
+            yield
+        finally:
+            sys.setprofile(original_profiler)
+
+    @staticmethod
+    def _get_func_variable_tracer(
+        _locals_data: Dict[str, Any], func_code: CodeType
+    ) -> Callable[[FrameType, str, Any], None]:
+        """Get a tracer to trace variable names in dsl.pipeline function.
+
+        :param _locals_data: A dict to save locals data.
+        :type _locals_data: dict
+        :param func_code: An code object to compare if current frame is inside user function.
+        :type func_code: CodeType
+        :return: A tracing function
+        :rtype: Callable[[FrameType, str, Any], None]
+        """
+
+        def tracer(frame: FrameType, event: str, arg: Any) -> None:  # pylint: disable=unused-argument
+            if frame.f_code == func_code and event == "return":
+                # Copy the locals of user's dsl function when it returns.
+                _locals_data.update(frame.f_locals.copy())
+
+        return tracer
+
+    def _call(self, func, _all_kwargs):
+        _locals = {}
+        func_variable_profiler = self._get_func_variable_tracer(_locals, func.__code__)
+        with self._replace_sys_profiler(func_variable_profiler):
+            outputs = func(**_all_kwargs)
+        return outputs, _locals
+
+
+class PersistentLocalsFunction(object):
+    def __init__(
+        self,
+        _func,
+        *,
+        _self: Optional[Any] = None,
+        skip_locals: Optional[List[str]] = None,
+    ):
+        """
+        :param _func: The function to be wrapped.
+        :param _self: If original func is a method, _self should be provided, which is the instance of the method.
+        :param skip_locals: A list of local variables to skip when saving the locals.
+        """
+        self._locals = {}
+        self._self = _self
+        # make function an instance method
+        self._func = MethodType(_func, self)
+        self._skip_locals = skip_locals
+
+    def __call__(__self, *args, **kwargs):  # pylint: disable=no-self-argument
+        # Use __self in case self is also passed as a named argument in kwargs
+        __self._locals.clear()
+        try:
+            if __self._self:
+                return __self._func(__self._self, *args, **kwargs)  # pylint: disable=not-callable
+            return __self._func(*args, **kwargs)  # pylint: disable=not-callable
+        finally:
+            # always pop skip locals even if exception is raised in user code
+            if __self._skip_locals is not None:
+                for skip_local in __self._skip_locals:
+                    __self._locals.pop(skip_local, None)
+
+    @property
+    def locals(self):
+        return self._locals
+
+
+def _source_template_func(mock_arg):
+    return mock_arg
+
+
+def _target_template_func(__self, mock_arg):
+    try:
+        return mock_arg
+    finally:
+        __self._locals = locals().copy()  # pylint: disable=protected-access
+
+
+try:
+    from bytecode import Bytecode, Instr, Label
+
+    class PersistentLocalsFunctionBytecodeBuilder(PersistentLocalsFunctionBuilder):
+        _template_separators = []
+        _template_separators_before_body = []
+        _template_separators_after_body = []
+        _template_body = []
+        _template_tail = None
+        __initialized = False
+
+        @classmethod
+        def _split(cls, instructions, separator, n=-1):
+            cur_start, index, result = 0, 0, []
+            while index < len(instructions) - len(separator) + 1:
+                if cls.is_instr_equal(instructions[index], separator[0]):
+                    for i, template_body_instruction in enumerate(separator):
+                        if not cls.is_instr_equal(instructions[index + i], template_body_instruction):
+                            break
+                    else:
+                        result.append(instructions[cur_start:index])
+                        cur_start = index + len(separator)
+                        index += len(separator)
+                        if len(result) == n:
+                            break
+                        continue
+                index += 1
+            result.append(instructions[cur_start:])
+            if n != -1 and len(result) != n:
+                msg = "can't split instructions into {} pieces with provided separators".format(n)
+                raise ValueError(msg)
+            return result
+
+        @classmethod
+        def _class_init_impl(cls):
+            """Override this method to implement different template matching algorithm."""
+            cls._template_separators_before_body, cls._template_separators_after_body = cls._split(
+                cls.get_instructions(_source_template_func),
+                separator=cls._get_mock_body_instructions(),
+                n=2,
+            )
+            # use None to indicate the body
+            cls._template_separators = (
+                cls._template_separators_before_body + [None] + cls._template_separators_after_body
+            )
+
+            cls._template_body = cls._split_instructions_based_on_template(
+                cls.get_instructions(_target_template_func),
+                remove_mock_body=True,
+            )
+            cls._template_tail = cls._template_body.pop()
+            if len(cls._template_body) != len(cls._template_body):
+                raise ValueError(cls.make_error("invalid_template"))
+
+        @classmethod
+        def __class_init(cls):
+            if cls.__initialized:
+                return
+
+            cls._class_init_impl()
+
+            cls.__initialized = True
+
+        def __init__(self):
+            self.__class_init()
+
+        # region methods depending on package bytecode
+        @classmethod
+        def get_instructions(cls, func):
+            return list(Bytecode.from_code(func.__code__))
+
+        @classmethod
+        def is_instr_equal(cls, instr1: Instr, instr2: Instr) -> bool:
+            if instr1 is None and instr2 is None:
+                return True
+            if instr1 is None or instr2 is None:
+                return False
+            if instr1.__class__ != instr2.__class__:
+                return False
+            if isinstance(instr1, Instr):
+                if isinstance(instr1.arg, Label) and isinstance(instr2.arg, Label):
+                    return True
+                return instr1.opcode == instr2.opcode and instr1.arg == instr2.arg
+            # objects like Label and TryBegin
+            return True
+
+        @classmethod
+        def is_instructions_equal(cls, instructions1: List[Instr], instructions2: List[Instr]) -> bool:
+            if len(instructions1) != len(instructions2):
+                return False
+            for instr1, instr2 in zip(instructions1, instructions2):
+                if not cls.is_instr_equal(instr1, instr2):
+                    return False
+            return True
+
+        def _create_code(self, instructions: List[Instr], base_func: Union[FunctionType, MethodType]) -> CodeType:
+            """Create the base bytecode for the function to be generated.
+
+            Will keep information of the function, such as name, globals, etc., but skip all instructions.
+
+            :param instructions: The list of instructions. Used to replace the instructions in base_func
+            :type instructions: List[Instr]
+            :param base_func: A function that provides base metadata (name, globals, etc...). Instructions will not
+                be kept
+            :type base_func: Union[FunctionType, MethodType]
+            :return: Generated code
+            :rtype: CodeType
+            """
+            fn_code = Bytecode.from_code(base_func.__code__)
+            fn_code.clear()
+            fn_code.extend(instructions)
+            fn_code.argcount += 1
+            fn_code.argnames.insert(0, self.injected_param)
+            return fn_code.to_code()
+
+        @classmethod
+        def _get_mock_body_instructions(cls):
+            return [Instr("LOAD_FAST", "mock_arg")]
+
+        # endregion
+
+        @classmethod
+        def _get_pieces(cls, instructions: List[Instr], separators: List[Instr]) -> List[List[Instr]]:
+            """Split the instructions into pieces by the separators.
+            Note that separators is a list of instructions. For example,
+            instructions: [I3, I1, I2, I3, I1, I3, I1, I2, I3]
+            separators: [I1, I2]
+            result: [[I3], [I3, I1, I3], [I3]]
+
+            :param instructions: The list of instructions to split
+            :type instructions: List[instr]
+            :param separators: The sequence of Instr to use as a delimiter
+            :type separators: List[Instr]
+            :return: A sublists of instructions that were delimited by separators
+            :rtype: List[List[Instr]]
+            """
+            separator_iter = iter(separators)
+
+            def get_next_separator():
+                try:
+                    while True:
+                        separator = next(separator_iter)
+                        if separator is not None:
+                            return separator
+                except StopIteration:
+                    return None
+
+            pieces = []
+            last_piece = []
+            cur_separator = get_next_separator()
+            for instr in instructions:
+                if cls.is_instr_equal(instr, cur_separator):
+                    # skip the separator
+                    pieces.append(last_piece)
+                    cur_separator = get_next_separator()
+                    last_piece = []
+                else:
+                    last_piece.append(instr)
+            pieces.append(last_piece)
+
+            if cur_separator is not None:
+                raise ValueError(cls.make_error("not_all_template_separators_used"))
+
+            return pieces
+
+        @classmethod
+        def _split_instructions_based_on_template(
+            cls,
+            instructions: List[Instr],
+            *,
+            remove_mock_body: bool = False,
+        ) -> List[List[Instr]]:
+            """Split instructions into several pieces by separators.
+            For example, in Python 3.11, the template source instructions will be:
+
+            .. code-block:: python
+
+                [
+                    Instr('RESUME', 0),  # initial instruction shared by all functions
+                    Instr('LOAD_FAST', 'mock_arg'),  # the body execution instruction
+                    Instr('RETURN_VALUE'),  # the return instruction shared by all functions
+                ]
+
+            Then the separators before body will be:
+
+            .. code-block:: python
+
+                [
+                    Instr('RESUME', 0),
+                ]
+
+            And the separators after body will be:
+
+            .. code-block:: python
+
+                [
+                    Instr('RETURN_VALUE'),
+                ]
+
+            For passed in instructions, we will split them with separators from beginning (the first RESUME) and
+            with reversed_separators from end (the last RETURN_VALUE).
+
+            :param instructions: The instructions to split
+            :type instructions: List[instr]
+            :keyword remove_mock_body: Whether to remove the mock body. Defaults to False
+            :paramtype remove_mock_body: bool
+            :return: The split instructions
+            :rtype: List[List[Instr]]
+            """
+            if remove_mock_body:
+                # this parameter should be set as True only when processing the template target function,
+                # when we should ignore the mock body
+                pieces = cls._get_pieces(
+                    instructions, cls._template_separators_before_body + cls._get_mock_body_instructions()
+                )
+            else:
+                pieces = cls._get_pieces(instructions, cls._template_separators_before_body)
+
+            reversed_pieces = cls._get_pieces(reversed(pieces.pop()), reversed(cls._template_separators_after_body))
+
+            while reversed_pieces:
+                pieces.append(list(reversed(reversed_pieces.pop())))
+
+            return pieces
+
+        def _build_instructions(self, func: Union[FunctionType, MethodType]) -> List[Instr]:
+            generated_instructions = []
+
+            for template_piece, input_piece, separator in zip(
+                self._template_body,
+                self._split_instructions_based_on_template(self.get_instructions(func)),
+                self._template_separators,
+            ):
+                generated_instructions.extend(template_piece)
+                generated_instructions.extend(input_piece)
+                if separator is not None:
+                    generated_instructions.append(separator)
+            generated_instructions.extend(self._template_tail)
+            return generated_instructions
+
+        def _build_func(self, func: Union[FunctionType, MethodType]) -> PersistentLocalsFunction:
+            """Build a persistent locals function from the given function. Use bytecode injection to add try...finally
+            statement around code to persistent the locals in the function.
+
+            It will change the func bytecode in this way:
+
+            .. code-block:: python
+
+                def func(__self, *func_args):
+                    try:
+                       the func code...
+                    finally:
+                       __self.locals = locals().copy()
+
+            You can get the locals in func by this code:
+
+            .. code-block:: python
+
+                builder = PersistentLocalsFunctionBuilder()
+                persistent_locals_func = builder.build(your_func)
+                # Execute your func
+                result = persistent_locals_func(*args)
+                # Get the locals in the func.
+                func_locals = persistent_locals_func.locals
+
+            :param func: The function to modify
+            :type func: Union[FunctionType, MethodType]
+            :return: The built persistent locals function
+            :rtype: PersistentLocalsFunction
+            """
+            generated_func = FunctionType(
+                self._create_code(self._build_instructions(func), func),
+                func.__globals__,
+                func.__name__,
+                func.__defaults__,
+                func.__closure__,
+            )
+            return PersistentLocalsFunction(
+                generated_func,
+                _self=func.__self__ if isinstance(func, MethodType) else None,
+                skip_locals=[self.injected_param],
+            )
+
+        def _call(self, func, _all_kwargs) -> Tuple[Any, dict]:
+            persistent_func = self._build_func(func)
+            outputs = persistent_func(**_all_kwargs)
+            return outputs, persistent_func.locals
+
+except ImportError:
+    # Fall back to the profiler implementation
+    class PersistentLocalsFunctionBytecodeBuilder(PersistentLocalsFunctionProfilerBuilder):
+        pass
+
+
+def _get_persistent_locals_builder() -> PersistentLocalsFunctionBuilder:
+    if is_bytecode_optimization_enabled():
+        return PersistentLocalsFunctionBytecodeBuilder()
+    return PersistentLocalsFunctionProfilerBuilder()
+
+
+def get_outputs_and_locals(func, _all_kwargs):
+    """Get outputs and locals from self.func. Locals will be used to update node variable names.
+
+    :param func: The function to execute.
+    :type func: Union[FunctionType, MethodType]
+    :param _all_kwargs: All kwargs to call self.func.
+    :type _all_kwargs: typing.Dict[str, typing.Any]
+    :return: A tuple of outputs and locals.
+    :rtype: typing.Tuple[typing.Dict, typing.Dict]
+    """
+    return _get_persistent_locals_builder().call(func, _all_kwargs)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_html_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_html_utils.py
new file mode 100644
index 00000000..faf6a406
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_html_utils.py
@@ -0,0 +1,155 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+from collections import OrderedDict
+from datetime import datetime, timedelta
+from html import escape
+
+SUPPORTED_VALUE_TYPE_TUPLE = (int, float, str, datetime, timedelta)
+TABLE_FMT = '<table style="width:100%">{0}</table>'
+ROW_FMT = "<tr>{0}</tr>"
+HEADER_FMT = "<th>{0}</th>"
+DATA_FMT = "<td>{0}</td>"
+# target="_blank" opens in new tab, rel="noopener" is for perf + security
+LINK_FMT = '<a href="{0}" target="_blank" rel="noopener">{1}</a>'
+
+
+def convert_dict_to_table(object_to_convert):
+    # Case 1: All non-collection values -> table of 1 row
+    # Case 2: All collection values, lens eq N -> assert lengths eq, table of N rows
+    # Case 3: collection and non-collection values -> table of 1 row, collections nest
+    # Case 4: All collection values, lens unequal -> table of 1 row, each is nested collection?
+
+    if not isinstance(object_to_convert, dict):
+        raise AssertionError("Expected a dict or subclass, got {0}".format(type(object_to_convert)))
+
+    if len(object_to_convert) == 0:
+        return ""
+
+    ordered_obj = OrderedDict(object_to_convert)
+
+    def is_collection_type(val):
+        return hasattr(val, "__len__") and not isinstance(val, str)
+
+    is_collection = [is_collection_type(value) for value in ordered_obj.values()]
+
+    all_rows = [get_header_row_string(ordered_obj.keys())]
+
+    def values_to_data_row(values):
+        cells = [to_html(value) for value in values]
+        return get_data_row_string(cells)
+
+    if all(is_collection):
+        # Cases 2 and 4
+        length = len(list(ordered_obj.values)[0])
+        if any(len(v) != length for v in ordered_obj.values()):
+            # Case 4
+            logging.warning("Uneven column lengths in table conversion")
+            all_rows.append(values_to_data_row(ordered_obj.values()))
+
+        else:
+            # Case 2 - sad transpose
+            for i in range(length):
+                value_list = [val[i] for val in ordered_obj.values()]
+                all_rows.append(values_to_data_row(value_list))
+
+    else:
+        # Cases 1 and 3
+        # Table of 1 row of values or mixed types, table of 1 row
+        all_rows.append(values_to_data_row(ordered_obj.values()))
+
+    return table_from_html_rows(all_rows)
+
+
+def convert_list_to_table(object_to_convert):
+    if not isinstance(object_to_convert, list):
+        raise AssertionError("Expected a list or subclass, got {0}".format(type(object_to_convert)))
+
+    if len(object_to_convert) == 0:
+        return ""
+
+    all_values = [to_html(element) for element in object_to_convert]
+    all_rows = [get_data_row_string([element]) for element in all_values]
+    return table_from_html_rows(all_rows)
+
+
+# Mapping from complex type to HTML converters
+# Unspecified types default to convert_value
+_type_to_converter = {list: convert_list_to_table, dict: convert_dict_to_table}
+
+
+def to_html(object_to_convert):
+    candidate_converters = [k for k in _type_to_converter if isinstance(object_to_convert, k)]
+
+    if len(candidate_converters) == 0:
+        converter = convert_value
+    elif len(candidate_converters) == 1:
+        converter = _type_to_converter[candidate_converters[0]]
+    else:
+        logging.warning("Multiple candidate converters found for type %s", type(object_to_convert))
+        converter = convert_value
+
+    converted_value = converter(object_to_convert)
+    return converted_value
+
+
+def is_string_link(string: str) -> bool:
+    return isinstance(string, str) and string.strip().lower().startswith("http")
+
+
+def make_link(link_string: str, link_text: str = "") -> str:
+    if not link_text:  # Actually want truthy string
+        link_text = "Link"
+    return LINK_FMT.format(escape(link_string), link_text)
+
+
+def convert_value(value: str) -> str:
+    if value is None:
+        return ""
+    if is_string_link(value):
+        return make_link(value)
+    if not isinstance(value, SUPPORTED_VALUE_TYPE_TUPLE):
+        logging.warning("Unsupported type %s for html, converting", type(value))
+
+    # TODO: Figure out a good escaping story here right now it breaks existing tags
+    return str(value)
+
+
+def get_header_row_string(column_headers):
+    headers = [HEADER_FMT.format(header) for header in column_headers]
+    return ROW_FMT.format("".join(headers))
+
+
+def get_data_row_string(data_values):
+    data = [DATA_FMT.format(datum) for datum in data_values]
+    return ROW_FMT.format("".join(data))
+
+
+def table_from_html_rows(list_of_rows):
+    # type/: (List[str]) -> str
+    return TABLE_FMT.format("".join(list_of_rows))
+
+
+def to_formatted_html_table(rows, header):
+    html = ["""<table style="width:100%; border:2px solid black" >"""]
+    if header is not None:
+        html_row = "</td><td>".join(column for column in header)
+        html.append(
+            """<tr style="font-weight:bold; border-bottom:1pt solid black; border-right: 1pt solid black;
+                    text-align: center"><td>{}</td></tr>""".format(
+                html_row
+            )
+        )
+
+    for row in rows:
+        html_row = "</td><td>".join(str(value) for value in row)
+        html.append(
+            """<tr style="width:100%; word-wrap: break-word; border-bottom:1pt solid black;
+                    text-align: center"><td>{}</td></tr>""".format(
+                html_row
+            )
+        )
+    html.append("</table>")
+    return "".join(html)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_http_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_http_utils.py
new file mode 100644
index 00000000..ddaae25e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_http_utils.py
@@ -0,0 +1,180 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+
+from functools import wraps
+from typing import Any, Callable, Optional
+
+from typing_extensions import Concatenate, ParamSpec, Self
+
+from azure.core.configuration import Configuration
+from azure.core.pipeline import Pipeline
+from azure.core.pipeline.policies import (
+    CustomHookPolicy,
+    HeadersPolicy,
+    HttpLoggingPolicy,
+    NetworkTraceLoggingPolicy,
+    ProxyPolicy,
+    RedirectPolicy,
+    RetryPolicy,
+    UserAgentPolicy,
+)
+from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import,no-name-in-module
+    HttpTransport,
+    RequestsTransport,
+)
+from azure.core.rest import HttpRequest, HttpResponse
+
+
+def _request_function(f: Callable[["HttpPipeline"], None]):
+    """A decorator that provides the implementation for the request-style convenience functions of the HttpPipeline
+    class.
+
+    :param Callable[[], None] f: A function whose name will be used as the http
+                                 request method
+    :return: An HTTP request function
+    :rtype: Callable
+    """
+
+    # This is a hack to provide richer typing for the decorated function
+    # The outer _ function allows us to pattern match on the parameter types
+    # of HttpRequest and forward those types to the decorated function
+    P = ParamSpec("P")
+
+    def _(_: Callable[Concatenate[str, P], Any] = HttpRequest):
+        @wraps(f)
+        # pylint: disable-next=docstring-missing-param
+        def decorated(self: "HttpPipeline", *args: P.args, **kwargs: P.kwargs) -> HttpResponse:
+            """A function that sends an HTTP request and returns the response.
+
+            Accepts the same parameters as azure.core.rest.HttpRequest, except for the method.
+            All other kwargs are forwarded to azure.core.Pipeline.run
+
+            :return: The request response
+            :rtype: HttpResponse
+            """
+            request = HttpRequest(
+                f.__name__.upper(),
+                *args,
+                params=kwargs.pop("params", None),
+                headers=kwargs.pop("headers", None),
+                json=kwargs.pop("json", None),
+                content=kwargs.pop("content", None),
+                data=kwargs.pop("data", None),
+                files=kwargs.pop("files", None),
+            )
+
+            return self.run(request, **kwargs).http_response
+
+        return decorated
+
+    return _()
+
+
+class HttpPipeline(Pipeline):
+    """A *very* thin wrapper over azure.core.pipeline.Pipeline that facilitates sending miscellaneous http requests by
+    adding:
+
+    * A requests-style api for sending http requests
+    * Facilities for populating policies for the client, include defaults,
+     and re-using policies from an existing client.
+    """
+
+    def __init__(
+        self,
+        *,
+        transport: Optional[HttpTransport] = None,
+        config: Optional[Configuration] = None,
+        user_agent_policy: Optional[UserAgentPolicy] = None,
+        headers_policy: Optional[HeadersPolicy] = None,
+        proxy_policy: Optional[ProxyPolicy] = None,
+        logging_policy: Optional[NetworkTraceLoggingPolicy] = None,
+        http_logging_policy: Optional[HttpLoggingPolicy] = None,
+        retry_policy: Optional[RetryPolicy] = None,
+        custom_hook_policy: Optional[CustomHookPolicy] = None,
+        redirect_policy: Optional[RedirectPolicy] = None,
+        **kwargs
+    ):
+        """
+
+        :param HttpTransport transport: Http Transport used for requests, defaults to RequestsTransport
+        :param Configuration config:
+        :param UserAgentPolicy user_agent_policy:
+        :param HeadersPolicy headers_policy:
+        :param ProxyPolicy proxy_policy:
+        :param NetworkTraceLoggingPolicy logging_policy:
+        :param HttpLoggingPolicy http_logging_policy:
+        :param RetryPolicy retry_policy:
+        :param CustomHookPolicy custom_hook_policy:
+        :param RedirectPolicy redirect_policy:
+        """
+        config = config or Configuration()
+        config.headers_policy = headers_policy or config.headers_policy or HeadersPolicy(**kwargs)
+        config.proxy_policy = proxy_policy or config.proxy_policy or ProxyPolicy(**kwargs)
+        config.redirect_policy = redirect_policy or config.redirect_policy or RedirectPolicy(**kwargs)
+        config.retry_policy = retry_policy or config.retry_policy or RetryPolicy(**kwargs)
+        config.custom_hook_policy = custom_hook_policy or config.custom_hook_policy or CustomHookPolicy(**kwargs)
+        config.logging_policy = logging_policy or config.logging_policy or NetworkTraceLoggingPolicy(**kwargs)
+        config.http_logging_policy = http_logging_policy or config.http_logging_policy or HttpLoggingPolicy(**kwargs)
+        config.user_agent_policy = user_agent_policy or config.user_agent_policy or UserAgentPolicy(**kwargs)
+        config.polling_interval = kwargs.get("polling_interval", 30)
+
+        super().__init__(
+            # RequestsTransport normally should not be imported outside of azure.core, since transports
+            # are meant to be user configurable.
+            # RequestsTransport is only used in this file as the default transport when not user specified.
+            transport=transport or RequestsTransport(**kwargs),
+            policies=[
+                config.headers_policy,
+                config.user_agent_policy,
+                config.proxy_policy,
+                config.redirect_policy,
+                config.retry_policy,
+                config.authentication_policy,
+                config.custom_hook_policy,
+                config.logging_policy,
+            ],
+        )
+
+        self._config = config
+
+    def with_policies(self, **kwargs) -> Self:
+        """A named constructor which facilitates creating a new pipeline using an existing one as a base.
+
+           Accepts the same parameters as __init__
+
+        :return: new Pipeline object with combined config of current object
+            and specified overrides
+        :rtype: Self
+        """
+        cls = self.__class__
+        return cls(config=self._config, transport=kwargs.pop("transport", self._transport), **kwargs)
+
+    @_request_function
+    def delete(self) -> None:
+        """Sends a DELETE request."""
+
+    @_request_function
+    def get(self) -> None:
+        """Sends a GET request."""
+
+    @_request_function
+    def head(self) -> None:
+        """Sends a HEAD request."""
+
+    @_request_function
+    def options(self) -> None:
+        """Sends a OPTIONS request."""
+
+    @_request_function
+    def patch(self) -> None:
+        """Sends a PATCH request."""
+
+    @_request_function
+    def post(self) -> None:
+        """Sends a POST request."""
+
+    @_request_function
+    def put(self) -> None:
+        """Sends a PUT request."""
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_logger_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_logger_utils.py
new file mode 100644
index 00000000..68a90aca
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_logger_utils.py
@@ -0,0 +1,62 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+import sys
+
+from opentelemetry import trace
+
+from azure.ai.ml._telemetry.logging_handler import AML_INTERNAL_LOGGER_NAMESPACE
+
+
+def initialize_logger_info(module_logger: logging.Logger, terminator="\n") -> None:
+    """Initializes the logger with INFO level and adds a StreamHandler to the logger.
+
+    :param module_logger: The logger to be initialized.
+    :type module_logger: logging.Logger
+    :param terminator: The line terminator for the StreamHandler. Defaults to a newline character.
+    :type terminator: str
+    :return: None
+    """
+    module_logger.setLevel(logging.INFO)
+    module_logger.propagate = False
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setLevel(logging.INFO)
+    handler.terminator = terminator
+    handler.flush = sys.stderr.flush
+    module_logger.addHandler(handler)
+
+
+tracer = trace.get_tracer(AML_INTERNAL_LOGGER_NAMESPACE)
+
+
+class OpsLogger:
+    """
+    A logger class for managing logging and tracing operations within a package.
+    This class initializes loggers and tracers for a specified package, and provides methods to update logging filters.
+    """
+
+    def __init__(self, name: str):
+        """
+        This constructor sets up the package logger, module logger, and tracer for the given package name.
+        :param name: The name of the package for which the logger is being initialized.
+        :type name: str
+        """
+        self.package_logger: logging.Logger = logging.getLogger(AML_INTERNAL_LOGGER_NAMESPACE).getChild(name)
+        self.package_logger.propagate = True
+        self.package_tracer = tracer
+        self.module_logger = logging.getLogger(name)
+        self.custom_dimensions = {}
+
+    def update_filter(self) -> None:
+        """
+        Update the logging filter for the package logger.
+        This method attaches the filter from the parent logger to the package logger,
+            as the parent's filter is not automatically propagated to the child logger.
+
+        :return: None
+        """
+        # Attach filter explicitly as parent logger's filter is not propagated to child logger
+        if self.package_logger.parent.filters:
+            self.package_logger.addFilter(self.package_logger.parent.filters[0])
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_package_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_package_utils.py
new file mode 100644
index 00000000..f50a6140
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_package_utils.py
@@ -0,0 +1,99 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+# pylint: disable=try-except-raise
+
+import logging
+
+
+from azure.ai.ml.entities import BatchDeployment, OnlineDeployment, Deployment
+from azure.ai.ml._restclient.v2023_04_01_preview.models import (
+    PackageRequest,
+    CodeConfiguration,
+    BaseEnvironmentId,
+    AzureMLOnlineInferencingServer,
+    AzureMLBatchInferencingServer,
+)
+from azure.ai.ml._restclient.v2021_10_01_dataplanepreview.models import (
+    PackageRequest as DataPlanePackageRequest,
+)
+from azure.ai.ml.constants._common import REGISTRY_URI_FORMAT
+
+from azure.ai.ml._utils._logger_utils import initialize_logger_info
+
+module_logger = logging.getLogger(__name__)
+initialize_logger_info(module_logger, terminator="")
+
+
+def package_deployment(deployment: Deployment, model_ops) -> Deployment:
+    model_str = deployment.model
+    model_version = model_str.split("/")[-1]
+    model_name = model_str.split("/")[-3]
+    target_environment_name = "packaged-env"
+
+    if deployment.code_configuration:
+        code_configuration = CodeConfiguration(
+            code_id=deployment.code_configuration.code,
+            scoring_script=deployment.code_configuration.scoring_script,
+        )
+    else:
+        code_configuration = None
+
+    if isinstance(deployment, OnlineDeployment):
+        inferencing_server = AzureMLOnlineInferencingServer(code_configuration=code_configuration)
+    elif isinstance(deployment, BatchDeployment):
+        inferencing_server = AzureMLBatchInferencingServer(code_configuration=code_configuration)
+    else:
+        inferencing_server = None
+
+    if deployment.environment:
+        base_environment_source = BaseEnvironmentId(
+            base_environment_source_type="EnvironmentAsset", resource_id=deployment.environment
+        )
+    else:
+        base_environment_source = None
+
+    package_request = (
+        PackageRequest(
+            target_environment_name=target_environment_name,
+            base_environment_source=base_environment_source,
+            inferencing_server=inferencing_server,
+        )
+        if not model_str.startswith(REGISTRY_URI_FORMAT)
+        else DataPlanePackageRequest(
+            inferencing_server=inferencing_server,
+            target_environment_id=target_environment_name,
+            base_environment_source=base_environment_source,
+        )
+    )
+
+    if deployment.environment:
+        if not model_str.startswith(REGISTRY_URI_FORMAT):
+            package_request.base_environment_source.resource_id = "azureml:/" + deployment.environment
+        else:
+            package_request.base_environment_source.resource_id = deployment.environment
+    if deployment.code_configuration:
+        if not deployment.code_configuration.code.startswith(REGISTRY_URI_FORMAT):
+            package_request.inferencing_server.code_configuration.code_id = (
+                "azureml:/" + deployment.code_configuration.code
+            )
+        else:
+            package_request.inferencing_server.code_configuration.code_id = deployment.code_configuration.code
+
+    try:
+        packaged_env = model_ops.package(
+            model_name,
+            model_version,
+            package_request=package_request,
+            skip_to_rest=True,
+        )
+        if not model_str.startswith(REGISTRY_URI_FORMAT):
+            deployment.environment = packaged_env.id
+        else:
+            deployment.environment = packaged_env.target_environment_id
+        deployment.model = None
+        deployment.code_configuration = None
+    except Exception:
+        raise
+    return deployment
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_pathspec.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_pathspec.py
new file mode 100644
index 00000000..a9a18239
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_pathspec.py
@@ -0,0 +1,587 @@
+# ---------------------------------------------------------
+# Copyright (c) 2013-2022 Caleb P. Burns credits dahlia <https://github.com/dahlia>
+# Licensed under the MPLv2 License. See License.txt in the project root for
+# license information.
+# ---------------------------------------------------------
+"""
+This file code has been vendored from pathspec repo.
+Please do not edit it, unless really necessary
+"""
+import dataclasses
+import os
+import posixpath
+import re
+import warnings
+from typing import Any, AnyStr, Iterable
+from typing import Match as MatchHint
+from typing import Optional
+from typing import Pattern as PatternHint
+from typing import Tuple, Union
+
+NORMALIZE_PATH_SEPS = [sep for sep in [os.sep, os.altsep] if sep and sep != posixpath.sep]
+
+# The encoding to use when parsing a byte string pattern.
+# This provides the base definition for patterns.
+_BYTES_ENCODING = "latin1"
+
+
+class Pattern(object):
+    """
+    The :class:`Pattern` class is the abstract definition of a pattern.
+    """
+
+    # Make the class dict-less.
+    __slots__ = ("include",)
+
+    def __init__(self, include: Optional[bool]) -> None:
+        """
+        Initializes the :class:`Pattern` instance.
+        *include* (:class:`bool` or :data:`None`) is whether the matched
+        files should be included (:data:`True`), excluded (:data:`False`),
+        or is a null-operation (:data:`None`).
+        """
+
+        self.include = include
+        """
+        *include* (:class:`bool` or :data:`None`) is whether the matched
+        files should be included (:data:`True`), excluded (:data:`False`),
+        or is a null-operation (:data:`None`).
+        """
+
+    def match(self, files: Iterable[str]) -> Iterable[str]:
+        """Matches this pattern against the specified files.
+
+        :param files: Contains each file relative to the root directory (e.g. :data:`"relative/path/to/file"`).
+        :type files: Iterable[str]
+        :return: The matched file paths
+        :rtype: Iterable[str]
+
+        .. deprecated::
+
+            This method is no longer used and has been replaced by :meth:`.match_file`. Use the :meth:`.match_file`
+            method with a loop for similar results.
+        """
+        warnings.warn(
+            (
+                "{0.__module__}.{0.__qualname__}.match() is deprecated. Use "
+                "{0.__module__}.{0.__qualname__}.match_file() with a loop for "
+                "similar results."
+            ).format(self.__class__),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        for file in files:
+            if self.match_file(file) is not None:
+                yield file
+
+    def match_file(self, file: str) -> Optional[Any]:
+        """Matches this pattern against the specified file.
+
+        :param file: The normalized file path to match against.
+        :type file: str
+        :return: Returns the match result if *file* matched; otherwise, :data:`None`.
+        :rtype: Optional[Any]
+        """
+        raise NotImplementedError(
+            ("{0.__module__}.{0.__qualname__} must override match_file().").format(self.__class__)
+        )
+
+
+class RegexPattern(Pattern):
+    """
+    The :class:`RegexPattern` class is an implementation of a pattern
+    using regular expressions.
+    """
+
+    # Keep the class dict-less.
+    __slots__ = ("regex",)
+
+    def __init__(
+        self,
+        pattern: Union[AnyStr, PatternHint],
+        include: Optional[bool] = None,
+    ) -> None:
+        """
+        Initializes the :class:`RegexPattern` instance.
+        *pattern* (:class:`str`, :class:`bytes`, :class:`re.Pattern`, or
+        :data:`None`) is the pattern to compile into a regular expression.
+        *include* (:class:`bool` or :data:`None`) must be :data:`None`
+        unless *pattern* is a precompiled regular expression (:class:`re.Pattern`)
+        in which case it is whether matched files should be included
+        (:data:`True`), excluded (:data:`False`), or is a null operation
+        (:data:`None`).
+            .. NOTE:: Subclasses do not need to support the *include*
+                parameter.
+        """
+
+        if isinstance(pattern, (str, bytes)):
+            assert include is None, ("include:{!r} must be null when pattern:{!r} is a string.").format(
+                include, pattern
+            )
+            regex, include = self.pattern_to_regex(pattern)
+            # NOTE: Make sure to allow a null regular expression to be
+            # returned for a null-operation.
+            if include is not None:
+                regex = re.compile(regex)
+
+        elif pattern is not None and hasattr(pattern, "match"):
+            # Assume pattern is a precompiled regular expression.
+            # - NOTE: Used specified *include*.
+            regex = pattern
+
+        elif pattern is None:
+            # NOTE: Make sure to allow a null pattern to be passed for a
+            # null-operation.
+            assert include is None, ("include:{!r} must be null when pattern:{!r} is null.").format(include, pattern)
+
+        else:
+            raise TypeError("pattern:{!r} is not a string, re.Pattern, or None.".format(pattern))
+
+        super(RegexPattern, self).__init__(include)
+
+        self.regex: PatternHint = regex
+        """
+        *regex* (:class:`re.Pattern`) is the regular expression for the
+        pattern.
+        """
+
+    def __eq__(self, other: "RegexPattern") -> bool:
+        """Tests the equality of this regex pattern with *other*
+
+        :param other: The regex pattern to test against
+        :type other: RegexPattern
+        :return: Return True if :attr:`~Pattern.include` and :attr:`~RegexPattern.regex`
+            are equal. False otherwise.
+        :rtype: bool
+        """
+        if isinstance(other, RegexPattern):
+            return self.include == other.include and self.regex == other.regex
+        return NotImplemented
+
+    def match_file(self, file: str) -> Optional["RegexMatchResult"]:
+        """Matches this pattern against the specified file.
+
+        :param file: File relative to the root directory (e.g., "relative/path/to/file").
+        :type file: str
+        :return: Returns the match result (:class:`RegexMatchResult`) if *file*
+           matched; otherwise, :data:`None`.
+        :rtype: Optional[RegexMatchResult]
+        """
+        if self.include is not None:
+            match = self.regex.match(file)
+            if match is not None:
+                return RegexMatchResult(match)
+
+        return None
+
+    @classmethod
+    def pattern_to_regex(cls, pattern: str) -> Tuple[str, bool]:
+        """Convert the pattern into an uncompiled regular expression.
+
+        :param pattern: The pattern to convert into a regular expression.
+        :type pattern: str
+        :return: Returns the uncompiled regular expression (:class:`str` or :data:`None`),
+            and whether matched files should be included (:data:`True`),
+            excluded (:data:`False`), or is a null-operation (:data:`None`).
+        :rtype: Tuple[str, bool]
+
+        .. NOTE::
+
+            The default implementation simply returns *pattern* and :data:`True`.
+        """
+        return pattern, True
+
+
+@dataclasses.dataclass()
+class RegexMatchResult(object):
+    """
+    The :class:`RegexMatchResult` data class is used to return information
+    about the matched regular expression.
+    """
+
+    # Keep the class dict-less.
+    __slots__ = ("match",)
+
+    match: MatchHint
+    """
+    *match* (:class:`re.Match`) is the regex match result.
+    """
+
+
+class GitWildMatchPatternError(ValueError):
+    """
+    The :class:`GitWildMatchPatternError` indicates an invalid git wild match
+    pattern.
+    """
+
+
+class GitWildMatchPattern(RegexPattern):
+    """
+    The :class:`GitWildMatchPattern` class represents a compiled Git
+    wildmatch pattern.
+    """
+
+    # Keep the dict-less class hierarchy.
+    __slots__ = ()
+
+    @classmethod
+    # pylint: disable=too-many-branches,too-many-statements
+    def pattern_to_regex(
+        cls,
+        pattern: AnyStr,
+    ) -> Tuple[Optional[AnyStr], Optional[bool]]:
+        """Convert the pattern into a regular expression.
+
+        :param pattern: Pattern to convert into a regular expression.
+        :type pattern: AnyStr
+        :return: A 2-tuple of:
+          * the uncompiled regular expression (:class:`str`, :class:`bytes`,
+            or :data:`None`)
+          * whether matched files should be included (:data:`True`), excluded (:data:`False`), or if it is a
+            null-operation (:data:`None`).
+        :rtype: Tuple[Optional[AnyStr], Optional[bool]]
+        """
+        if isinstance(pattern, str):
+            return_type = str
+        elif isinstance(pattern, bytes):
+            return_type = bytes
+            pattern = pattern.decode(_BYTES_ENCODING)
+        else:
+            raise TypeError(f"pattern:{pattern!r} is not a unicode or byte string.")
+
+        original_pattern = pattern
+        pattern = pattern.strip()
+
+        if pattern.startswith("#"):
+            # A pattern starting with a hash ('#') serves as a comment
+            # (neither includes nor excludes files). Escape the hash with a
+            # back-slash to match a literal hash (i.e., '\#').
+            regex = None
+            include = None
+
+        elif pattern == "/":
+            # EDGE CASE: According to `git check-ignore` (v2.4.1), a single
+            # '/' does not match any file.
+            regex = None
+            include = None
+
+        elif pattern:
+            if pattern.startswith("!"):
+                # A pattern starting with an exclamation mark ('!') negates the
+                # pattern (exclude instead of include). Escape the exclamation
+                # mark with a back-slash to match a literal exclamation mark
+                # (i.e., '\!').
+                include = False
+                # Remove leading exclamation mark.
+                pattern = pattern[1:]
+            else:
+                include = True
+
+            # Allow a regex override for edge cases that cannot be handled
+            # through normalization.
+            override_regex = None
+
+            # Split pattern into segments.
+            pattern_segs = pattern.split("/")
+
+            # Normalize pattern to make processing easier.
+
+            # EDGE CASE: Deal with duplicate double-asterisk sequences.
+            # Collapse each sequence down to one double-asterisk. Iterate over
+            # the segments in reverse and remove the duplicate double
+            # asterisks as we go.
+            for i in range(len(pattern_segs) - 1, 0, -1):
+                prev = pattern_segs[i - 1]
+                seg = pattern_segs[i]
+                if prev == "**" and seg == "**":
+                    del pattern_segs[i]
+
+            if len(pattern_segs) == 2 and pattern_segs[0] == "**" and not pattern_segs[1]:
+                # EDGE CASE: The '**/' pattern should match everything except
+                # individual files in the root directory. This case cannot be
+                # adequately handled through normalization. Use the override.
+                override_regex = "^.+(?P<ps_d>/).*$"
+
+            if not pattern_segs[0]:
+                # A pattern beginning with a slash ('/') will only match paths
+                # directly on the root directory instead of any descendant
+                # paths. So, remove empty first segment to make pattern relative
+                # to root.
+                del pattern_segs[0]
+
+            elif len(pattern_segs) == 1 or (len(pattern_segs) == 2 and not pattern_segs[1]):
+                # A single pattern without a beginning slash ('/') will match
+                # any descendant path. This is equivalent to "**/{pattern}". So,
+                # prepend with double-asterisks to make pattern relative to
+                # root.
+                # EDGE CASE: This also holds for a single pattern with a
+                # trailing slash (e.g. dir/).
+                if pattern_segs[0] != "**":
+                    pattern_segs.insert(0, "**")
+
+            else:
+                # EDGE CASE: A pattern without a beginning slash ('/') but
+                # contains at least one prepended directory (e.g.
+                # "dir/{pattern}") should not match "**/dir/{pattern}",
+                # according to `git check-ignore` (v2.4.1).
+                pass
+
+            if not pattern_segs:
+                # After resolving the edge cases, we end up with no pattern at
+                # all. This must be because the pattern is invalid.
+                raise GitWildMatchPatternError(f"Invalid git pattern: {original_pattern!r}")
+
+            if not pattern_segs[-1] and len(pattern_segs) > 1:
+                # A pattern ending with a slash ('/') will match all descendant
+                # paths if it is a directory but not if it is a regular file.
+                # This is equivalent to "{pattern}/**". So, set last segment to
+                # a double-asterisk to include all descendants.
+                pattern_segs[-1] = "**"
+
+            if override_regex is None:
+                # Build regular expression from pattern.
+                output = ["^"]
+                need_slash = False
+                end = len(pattern_segs) - 1
+                for i, seg in enumerate(pattern_segs):
+                    if seg == "**":
+                        if i == 0 and i == end:
+                            # A pattern consisting solely of double-asterisks ('**')
+                            # will match every path.
+                            output.append(".+")
+                        elif i == 0:
+                            # A normalized pattern beginning with double-asterisks
+                            # ('**') will match any leading path segments.
+                            output.append("(?:.+/)?")
+                            need_slash = False
+                        elif i == end:
+                            # A normalized pattern ending with double-asterisks ('**')
+                            # will match any trailing path segments.
+                            output.append("(?P<ps_d>/).*")
+                        else:
+                            # A pattern with inner double-asterisks ('**') will match
+                            # multiple (or zero) inner path segments.
+                            output.append("(?:/.+)?")
+                            need_slash = True
+
+                    elif seg == "*":
+                        # Match single path segment.
+                        if need_slash:
+                            output.append("/")
+
+                        output.append("[^/]+")
+
+                        if i == end:
+                            # A pattern ending without a slash ('/') will match a file
+                            # or a directory (with paths underneath it). E.g., "foo"
+                            # matches "foo", "foo/bar", "foo/bar/baz", etc.
+                            output.append("(?:(?P<ps_d>/).*)?")
+
+                        need_slash = True
+
+                    else:
+                        # Match segment glob pattern.
+                        if need_slash:
+                            output.append("/")
+
+                        try:
+                            output.append(cls._translate_segment_glob(seg))
+                        except ValueError as e:
+                            raise GitWildMatchPatternError(f"Invalid git pattern: {original_pattern!r}") from e
+
+                        if i == end:
+                            # A pattern ending without a slash ('/') will match a file
+                            # or a directory (with paths underneath it). E.g., "foo"
+                            # matches "foo", "foo/bar", "foo/bar/baz", etc.
+                            output.append("(?:(?P<ps_d>/).*)?")
+
+                        need_slash = True
+
+                output.append("$")
+                regex = "".join(output)
+
+            else:
+                # Use regex override.
+                regex = override_regex
+
+        else:
+            # A blank pattern is a null-operation (neither includes nor
+            # excludes files).
+            regex = None
+            include = None
+
+        if regex is not None and return_type is bytes:
+            regex = regex.encode(_BYTES_ENCODING)
+
+        return regex, include
+
+    @staticmethod
+    def _translate_segment_glob(pattern: str) -> str:
+        """Translates the glob pattern to a regular expression. This is used in
+        the constructor to translate a path segment glob pattern to its
+        corresponding regular expression.
+
+        :param pattern:  The glob pattern.
+        :type pattern: str
+        :return: The regular expression
+        :rtype: str
+        """
+        # NOTE: This is derived from `fnmatch.translate()` and is similar to
+        # the POSIX function `fnmatch()` with the `FNM_PATHNAME` flag set.
+
+        escape = False
+        regex = ""
+        i, end = 0, len(pattern)
+        while i < end:
+            # Get next character.
+            char = pattern[i]
+            i += 1
+
+            if escape:
+                # Escape the character.
+                escape = False
+                regex += re.escape(char)
+
+            elif char == "\\":
+                # Escape character, escape next character.
+                escape = True
+
+            elif char == "*":
+                # Multi-character wildcard. Match any string (except slashes),
+                # including an empty string.
+                regex += "[^/]*"
+
+            elif char == "?":
+                # Single-character wildcard. Match any single character (except
+                # a slash).
+                regex += "[^/]"
+
+            elif char == "[":
+                # Bracket expression wildcard. Except for the beginning
+                # exclamation mark, the whole bracket expression can be used
+                # directly as regex but we have to find where the expression
+                # ends.
+                # - "[][!]" matches ']', '[' and '!'.
+                # - "[]-]" matches ']' and '-'.
+                # - "[!]a-]" matches any character except ']', 'a' and '-'.
+                j = i
+                # Pass back expression negation.
+                if j < end and pattern[j] == "!":
+                    j += 1
+                # Pass first closing bracket if it is at the beginning of the
+                # expression.
+                if j < end and pattern[j] == "]":
+                    j += 1
+                # Find closing bracket. Stop once we reach the end or find it.
+                while j < end and pattern[j] != "]":
+                    j += 1
+
+                if j < end:
+                    # Found end of bracket expression. Increment j to be one past
+                    # the closing bracket:
+                    #
+                    #  [...]
+                    #   ^   ^
+                    #   i   j
+                    #
+                    j += 1
+                    expr = "["
+
+                    if pattern[i] == "!":
+                        # Bracket expression needs to be negated.
+                        expr += "^"
+                        i += 1
+                    elif pattern[i] == "^":
+                        # POSIX declares that the regex bracket expression negation
+                        # "[^...]" is undefined in a glob pattern. Python's
+                        # `fnmatch.translate()` escapes the caret ('^') as a
+                        # literal. To maintain consistency with undefined behavior,
+                        # I am escaping the '^' as well.
+                        expr += "\\^"
+                        i += 1
+
+                    # Build regex bracket expression. Escape slashes so they are
+                    # treated as literal slashes by regex as defined by POSIX.
+                    expr += pattern[i:j].replace("\\", "\\\\")
+
+                    # Add regex bracket expression to regex result.
+                    regex += expr
+
+                    # Set i to one past the closing bracket.
+                    i = j
+
+                else:
+                    # Failed to find closing bracket, treat opening bracket as a
+                    # bracket literal instead of as an expression.
+                    regex += "\\["
+
+            else:
+                # Regular character, escape it for regex.
+                regex += re.escape(char)
+
+        if escape:
+            raise ValueError(f"Escape character found with no next character to escape: {pattern!r}")
+
+        return regex
+
+    @staticmethod
+    def escape(s: AnyStr) -> AnyStr:
+        """Escape special characters in the given string.
+
+        :param s:  a filename or a string that you want to escape, usually before adding it to a ".gitignore".
+        :type s: AnyStr
+        :return: The escaped string
+        :rtype: Union[str, bytes]
+        """
+        if isinstance(s, str):
+            return_type = str
+            string = s
+        elif isinstance(s, bytes):
+            return_type = bytes
+            string = s.decode(_BYTES_ENCODING)
+        else:
+            raise TypeError(f"s:{s!r} is not a unicode or byte string.")
+
+        # Reference: https://git-scm.com/docs/gitignore#_pattern_format
+        meta_characters = r"[]!*#?"
+
+        out_string = "".join("\\" + x if x in meta_characters else x for x in string)
+
+        if return_type is bytes:
+            return out_string.encode(_BYTES_ENCODING)
+        return out_string
+
+
+def normalize_file(file: Union[str, os.PathLike], separators: Optional[Iterable[str]] = None) -> str:
+    """Normalizes the file path to use the POSIX path separator (i.e.,
+    ``'/'``), and make the paths relative (remove leading ``'/'``).
+
+    :param file: The file path.
+    :type file: Union[str, os.PathLike]
+    :param separators: The path separators to normalize. This does not need to include the POSIX path separator
+        (``'/'``), but including it will not affect the results. Default is :data:`None` for
+        :data:`NORMALIZE_PATH_SEPS`. To prevent normalization, pass an empty container (e.g., an empty tuple ``()``).
+    :type separators: Optional[Iterable[str]]
+    :return: The normalized file path.
+    :rtype: str
+    """
+    # Normalize path separators.
+    if separators is None:
+        separators = NORMALIZE_PATH_SEPS
+
+    # Convert path object to string.
+    norm_file = str(file)
+
+    for sep in separators:
+        norm_file = norm_file.replace(sep, posixpath.sep)
+
+    if norm_file.startswith("/"):
+        # Make path relative.
+        norm_file = norm_file[1:]
+
+    elif norm_file.startswith("./"):
+        # Remove current directory prefix.
+        norm_file = norm_file[2:]
+
+    return norm_file
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_preflight_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_preflight_utils.py
new file mode 100644
index 00000000..2a8e8053
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_preflight_utils.py
@@ -0,0 +1,26 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+from typing import Optional
+
+from azure.ai.ml._azure_environments import _get_base_url_from_metadata
+from azure.ai.ml._vendor.azure_resources._resource_management_client import ResourceManagementClient
+from azure.ai.ml._vendor.azure_resources.operations import DeploymentsOperations
+from azure.ai.ml.constants._common import ArmConstants
+from azure.core.credentials import TokenCredential
+
+module_logger = logging.getLogger(__name__)
+
+
+def get_deployments_operation(credentials: TokenCredential, subscription_id: str) -> Optional[DeploymentsOperations]:
+    if subscription_id is None:
+        return None
+    client = ResourceManagementClient(
+        credential=credentials,
+        subscription_id=subscription_id,
+        base_url=_get_base_url_from_metadata(),
+        api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION,
+    )
+    return client.deployments
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_registry_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_registry_utils.py
new file mode 100644
index 00000000..09c5d1ae
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_registry_utils.py
@@ -0,0 +1,222 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+from typing import Optional, Tuple
+
+from typing_extensions import Literal
+
+from azure.ai.ml._azure_environments import _get_default_cloud_name, _get_registry_discovery_endpoint_from_metadata
+from azure.ai.ml._restclient.registry_discovery import AzureMachineLearningWorkspaces as ServiceClientRegistryDiscovery
+from azure.ai.ml._restclient.v2021_10_01_dataplanepreview import AzureMachineLearningWorkspaces
+from azure.ai.ml._restclient.v2021_10_01_dataplanepreview.models import (
+    BlobReferenceSASRequestDto,
+    TemporaryDataReferenceRequestDto,
+)
+from azure.ai.ml.constants._common import REGISTRY_ASSET_ID
+from azure.ai.ml.exceptions import MlException
+from azure.core.exceptions import HttpResponseError
+
+module_logger = logging.getLogger(__name__)
+
+MFE_PATH_PREFIX = "mferp/managementfrontend"
+
+
+class RegistryDiscovery:
+    def __init__(
+        self,
+        credential: str,
+        registry_name: str,
+        service_client_registry_discovery_client: ServiceClientRegistryDiscovery,
+        **kwargs,
+    ):
+        self.credential = credential
+        self.registry_name = registry_name
+        self.service_client_registry_discovery_client = service_client_registry_discovery_client
+        self.kwargs = kwargs
+        self._resource_group = None
+        self._subscription_id = None
+        self._base_url = None
+        self.workspace_region = kwargs.get("workspace_location", None)
+
+    def _get_registry_details(self) -> str:
+        response = self.service_client_registry_discovery_client.registry_management_non_workspace.registry_management_non_workspace(  # pylint: disable=line-too-long
+            self.registry_name
+        )
+        if self.workspace_region:
+            _check_region_fqdn(self.workspace_region, response)
+            self._base_url = f"https://cert-{self.workspace_region}.experiments.azureml.net/{MFE_PATH_PREFIX}"
+        else:
+            self._base_url = f"{response.primary_region_resource_provider_uri}{MFE_PATH_PREFIX}"
+        self._subscription_id = response.subscription_id
+        self._resource_group = response.resource_group
+
+    def get_registry_service_client(self) -> AzureMachineLearningWorkspaces:
+        self._get_registry_details()
+        self.kwargs.pop("subscription_id", None)
+        self.kwargs.pop("resource_group", None)
+        service_client_10_2021_dataplanepreview = AzureMachineLearningWorkspaces(
+            subscription_id=self._subscription_id,
+            resource_group=self._resource_group,
+            credential=self.credential,
+            base_url=self._base_url,
+            **self.kwargs,
+        )
+        return service_client_10_2021_dataplanepreview
+
+    @property
+    def subscription_id(self) -> str:
+        """The subscription id of the registry.
+
+        :return: Subscription Id
+        :rtype: str
+        """
+        return self._subscription_id
+
+    @property
+    def resource_group(self) -> str:
+        """The resource group of the registry.
+
+        :return: Resource Group
+        :rtype: str
+        """
+        return self._resource_group
+
+
+def get_sas_uri_for_registry_asset(service_client, name, version, resource_group, registry, body) -> str:
+    """Get sas_uri for registry asset.
+
+    :param service_client: Service client
+    :type service_client: AzureMachineLearningWorkspaces
+    :param name: Asset name
+    :type name: str
+    :param version: Asset version
+    :type version: str
+    :param resource_group: Resource group
+    :type resource_group: str
+    :param registry: Registry name
+    :type registry: str
+    :param body: Request body
+    :type body: TemporaryDataReferenceRequestDto
+    :rtype: str
+    """
+    sas_uri = None
+    try:
+        res = service_client.temporary_data_references.create_or_get_temporary_data_reference(
+            name=name,
+            version=version,
+            resource_group_name=resource_group,
+            registry_name=registry,
+            body=body,
+        )
+        sas_uri = res.blob_reference_for_consumption.credential.additional_properties["sasUri"]
+    except HttpResponseError as e:
+        # "Asset already exists" exception is thrown from service with error code 409, that we need to ignore
+        if e.status_code == 409:
+            module_logger.debug("Skipping file upload, reason:  %s", str(e.reason))
+        else:
+            raise e
+    return sas_uri
+
+
+def get_asset_body_for_registry_storage(
+    registry_name: str, asset_type: str, asset_name: str, asset_version: str
+) -> TemporaryDataReferenceRequestDto:
+    """Get Asset body for registry.
+
+    :param registry_name: Registry name.
+    :type registry_name: str
+    :param asset_type: Asset type.
+    :type asset_type: str
+    :param asset_name: Asset name.
+    :type asset_name: str
+    :param asset_version: Asset version.
+    :type asset_version: str
+    :return: The temporary data reference request dto
+    :rtype: TemporaryDataReferenceRequestDto
+    """
+    body = TemporaryDataReferenceRequestDto(
+        asset_id=REGISTRY_ASSET_ID.format(registry_name, asset_type, asset_name, asset_version),
+        temporary_data_reference_type="TemporaryBlobReference",
+    )
+    return body
+
+
+def get_storage_details_for_registry_assets(
+    service_client: AzureMachineLearningWorkspaces,
+    asset_type: str,
+    asset_name: str,
+    asset_version: str,
+    rg_name: str,
+    reg_name: str,
+    uri: str,
+) -> Tuple[str, Literal["NoCredentials", "SAS"]]:
+    """Get storage details for registry assets.
+
+    :param service_client: AzureMachineLearningWorkspaces service client.
+    :type service_client: AzureMachineLearningWorkspaces
+    :param asset_type: Asset type.
+    :type asset_type: str
+    :param asset_name: Asset name.
+    :type asset_name: str
+    :param asset_version: Asset version.
+    :type asset_version: str
+    :param rg_name: Resource group name.
+    :type rg_name: str
+    :param reg_name: Registry name
+    :type reg_name: str
+    :param uri: asset uri
+    :type uri: str
+    :return: A 2-tuple of a URI and a string. Either:
+      * A blob uri and "NoCredentials"
+      * A sas URI and "SAS"
+    :rtype: Tuple[str, Literal["NoCredentials", "SAS"]]
+    """
+    body = BlobReferenceSASRequestDto(
+        asset_id=REGISTRY_ASSET_ID.format(reg_name, asset_type, asset_name, asset_version),
+        blob_uri=uri,
+    )
+    sas_uri = service_client.data_references.get_blob_reference_sas(
+        name=asset_name,
+        version=asset_version,
+        resource_group_name=rg_name,
+        registry_name=reg_name,
+        body=body,
+    )
+    if sas_uri.blob_reference_for_consumption.credential.credential_type == "no_credentials":
+        return sas_uri.blob_reference_for_consumption.blob_uri, "NoCredentials"
+
+    return (
+        sas_uri.blob_reference_for_consumption.credential.additional_properties["sasUri"],
+        "SAS",
+    )
+
+
+def get_registry_client(credential, registry_name, workspace_location: Optional[str] = None, **kwargs):
+    base_url = _get_registry_discovery_endpoint_from_metadata(_get_default_cloud_name())
+    kwargs.pop("base_url", None)
+
+    service_client_registry_discovery_client = ServiceClientRegistryDiscovery(
+        credential=credential, base_url=base_url, **kwargs
+    )
+    if workspace_location:
+        workspace_kwargs = {"workspace_location": workspace_location}
+        kwargs.update(workspace_kwargs)
+
+    registry_discovery = RegistryDiscovery(
+        credential, registry_name, service_client_registry_discovery_client, **kwargs
+    )
+    service_client_10_2021_dataplanepreview = registry_discovery.get_registry_service_client()
+    subscription_id = registry_discovery.subscription_id
+    resource_group_name = registry_discovery.resource_group
+    return service_client_10_2021_dataplanepreview, resource_group_name, subscription_id
+
+
+def _check_region_fqdn(workspace_region, response):
+    if workspace_region in response.additional_properties["registryFqdns"].keys():
+        return
+    regions = list(response.additional_properties["registryFqdns"].keys())
+    msg = f"Workspace region {workspace_region} not supported by the \
+            registry {response.registry_name} regions {regions}"
+    raise MlException(message=msg, no_personal_data_message=msg)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_storage_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_storage_utils.py
new file mode 100644
index 00000000..df2ec65f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_storage_utils.py
@@ -0,0 +1,207 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+import re
+from typing import Optional, Tuple, Union
+
+from azure.ai.ml._artifacts._blob_storage_helper import BlobStorageClient
+from azure.ai.ml._artifacts._constants import STORAGE_URI_REGEX
+from azure.ai.ml._artifacts._fileshare_storage_helper import FileStorageClient
+from azure.ai.ml._artifacts._gen2_storage_helper import Gen2StorageClient
+from azure.ai.ml._azure_environments import _get_storage_endpoint_from_metadata
+from azure.ai.ml._restclient.v2022_10_01.models import DatastoreType
+from azure.ai.ml.constants._common import (
+    FILE_PREFIX,
+    FOLDER_PREFIX,
+    JOB_URI_REGEX_FORMAT,
+    LONG_URI_FORMAT,
+    LONG_URI_REGEX_FORMAT,
+    MLFLOW_URI_REGEX_FORMAT,
+    OUTPUT_URI_REGEX_FORMAT,
+    SHORT_URI_FORMAT,
+    SHORT_URI_REGEX_FORMAT,
+    STORAGE_ACCOUNT_URLS,
+)
+from azure.ai.ml.exceptions import ErrorTarget, MlException, ValidationErrorType, ValidationException
+
+module_logger = logging.getLogger(__name__)
+
+
+class AzureMLDatastorePathUri:
+    """Parser for an azureml:// datastore path URI, e.g.: azureml://datastores/mydatastore/paths/images/dogs'.
+
+    :param uri: The AzureML datastore path URI.
+    :type uri: str
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the AzureML datastore
+        path URI is incorrectly formatted.
+    '
+    """
+
+    def __init__(self, uri: str):
+        if uri.startswith(FILE_PREFIX):
+            uri = uri[len(FILE_PREFIX) :]
+        elif uri.startswith(FOLDER_PREFIX):
+            uri = uri[len(FOLDER_PREFIX) :]
+        self.uri = uri
+
+        short_uri_match = re.match(SHORT_URI_REGEX_FORMAT, uri)
+        ml_flow_uri_match = re.match(MLFLOW_URI_REGEX_FORMAT, uri)
+        job_uri_match = re.match(JOB_URI_REGEX_FORMAT, uri)
+        long_uri_match = re.match(LONG_URI_REGEX_FORMAT, uri)
+        output_uri_match = re.match(OUTPUT_URI_REGEX_FORMAT, uri)
+
+        if short_uri_match:
+            self.datastore = short_uri_match.group(1)
+            self.path = short_uri_match.group(2)
+            self.uri_type = "Datastore"
+            self.workspace_name = None
+            self.resource_group = None
+            self.subscription_id = None
+        elif ml_flow_uri_match:
+            self.datastore = ml_flow_uri_match.group(1)
+            self.path = ml_flow_uri_match.group(2)
+            self.uri_type = "MlFlow"
+            self.workspace_name = None
+            self.resource_group = None
+            self.subscription_id = None
+        elif job_uri_match:
+            self.datastore = job_uri_match.group(1)
+            self.path = job_uri_match.group(2)
+            self.uri_type = "Job"
+            self.workspace_name = None
+            self.resource_group = None
+            self.subscription_id = None
+        elif output_uri_match:
+            self.datastore = output_uri_match.group(1)
+            self.path = output_uri_match.group(2)
+            self.uri_type = None
+            self.workspace_name = None
+            self.resource_group = None
+            self.subscription_id = None
+        elif long_uri_match:
+            self.datastore = long_uri_match.group(4)
+            self.path = long_uri_match.group(5)
+            self.uri_type = "Datastore"
+            self.workspace_name = long_uri_match.group(3)
+            self.resource_group = long_uri_match.group(2)
+            self.subscription_id = long_uri_match.group(1)
+        else:
+            msg = "Invalid AzureML datastore path URI {}"
+            raise ValidationException(
+                message=msg.format(uri),
+                no_personal_data_message=msg.format("[uri]"),
+                target=ErrorTarget.DATASTORE,
+                error_type=ValidationErrorType.INVALID_VALUE,
+            )
+
+    def to_short_uri(self) -> str:
+        return SHORT_URI_FORMAT.format(self.datastore, self.path)
+
+    def to_long_uri(self, subscription_id: str, resource_group_name: str, workspace_name: str) -> str:
+        return LONG_URI_FORMAT.format(
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            self.datastore,
+            self.path,
+        )
+
+    def get_uri_type(self) -> str:
+        if self.uri[0:20] == "azureml://datastores":
+            return "Datastore"
+        if self.uri[0:14] == "azureml://jobs":
+            return "Jobs"
+
+        if self.uri[0 : self.uri.find(":")] == "runs":
+            return "MLFlow"
+        msg = "Invalid uri format for {}. URI must start with 'azureml://' or 'runs:/'"
+        raise ValidationException(
+            message=msg.format(self.uri),
+            no_personal_data_message=msg.format("[self.uri]"),
+            target=ErrorTarget.DATASTORE,
+            error_type=ValidationErrorType.INVALID_VALUE,
+        )
+
+
+def get_storage_client(
+    credential: str,
+    storage_account: str,
+    storage_type: Union[DatastoreType, str] = DatastoreType.AZURE_BLOB,
+    account_url: Optional[str] = None,
+    container_name: Optional[str] = None,
+) -> Union[BlobStorageClient, FileStorageClient, Gen2StorageClient]:
+    """Return a storage client class instance based on the storage account type.
+
+    :param credential: The credential
+    :type credential: str
+    :param storage_account: The storage_account name
+    :type storage_account: str
+    :param storage_type: The storage type
+    :type storage_type: Union[DatastoreType, str]
+    :param account_url: The account url
+    :type account_url: Optional[str]
+    :param container_name: The container name
+    :type container_name: Optional[str]
+    :return: The storage client
+    :rtype: Union[BlobStorageClient, FileStorageClient, Gen2StorageClient]
+    """
+    client_builders = {
+        DatastoreType.AZURE_BLOB: lambda credential, container_name, account_url: BlobStorageClient(
+            credential=credential, account_url=account_url, container_name=container_name
+        ),
+        DatastoreType.AZURE_DATA_LAKE_GEN2: lambda credential, container_name, account_url: Gen2StorageClient(
+            credential=credential, file_system=container_name, account_url=account_url
+        ),
+        DatastoreType.AZURE_FILE: lambda credential, container_name, account_url: FileStorageClient(
+            credential=credential, file_share_name=container_name, account_url=account_url
+        ),
+    }
+
+    if storage_type not in client_builders:
+        msg = (
+            f"Datastore type {storage_type} is not supported. Supported storage"
+            + f"types for artifact upload include: {*client_builders,}"
+        )
+        raise ValidationException(
+            message=msg,
+            no_personal_data_message=msg,
+            target=ErrorTarget.DATASTORE,
+            error_type=ValidationErrorType.INVALID_VALUE,
+        )
+
+    storage_endpoint = _get_storage_endpoint_from_metadata()
+    if not account_url and storage_endpoint:
+        account_url = STORAGE_ACCOUNT_URLS[storage_type].format(storage_account, storage_endpoint)
+    return client_builders[storage_type](credential, container_name, account_url)
+
+
+def get_artifact_path_from_storage_url(blob_url: str, container_name: dict) -> str:
+    split_blob_url = blob_url.split(container_name)
+    if len(split_blob_url) > 1:
+        path = split_blob_url[-1]
+        if path.startswith("/"):
+            return path[1:]
+        return path
+    return blob_url
+
+
+def get_ds_name_and_path_prefix(asset_uri: str, registry_name: Optional[str] = None) -> Tuple[str, str]:
+    if registry_name:
+        try:
+            split_paths = re.findall(STORAGE_URI_REGEX, asset_uri)
+            path_prefix = split_paths[0][-1]
+        except Exception as e:
+            msg = "Registry asset URI could not be parsed."
+            raise MlException(message=msg, no_personal_data_message=msg) from e
+        ds_name = None
+    else:
+        try:
+            ds_name = asset_uri.split("paths")[0].split("/")[-2]
+            path_prefix = asset_uri.split("paths")[1][1:]
+        except Exception as e:
+            msg = "Workspace asset URI could not be parsed."
+            raise MlException(message=msg, no_personal_data_message=msg) from e
+
+    return ds_name, path_prefix
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/__init__.py
new file mode 100644
index 00000000..dcf2df4f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/__init__.py
@@ -0,0 +1,57 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+from azure.ai.ml.entities import Job
+from azure.ai.ml.entities._job.base_job import _BaseJob
+from azure.ai.ml.entities._system_data import SystemData
+
+from ._restclient.index_service_apis import IndexServiceAPIs
+from ._restclient.index_service_apis.models import (
+    CrossRegionIndexEntitiesRequest,
+    IndexEntitiesRequest,
+    IndexEntitiesRequestFilter,
+    IndexEntitiesRequestOrder,
+    IndexEntitiesRequestOrderDirection,
+    IndexEntityResponse,
+)
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore
+
+
+def index_entity_response_to_job(entity: IndexEntityResponse) -> Job:
+    properties = entity.properties
+    annotations = entity.annotations
+    creation_context = SystemData(
+        created_by=properties.creation_context.created_by.user_name,
+        created_by_type="User",
+        created_at=properties.creation_context.created_time,
+    )
+
+    return _BaseJob(
+        name=properties.additional_properties["runId"],
+        display_name=annotations.additional_properties["displayName"],
+        description=annotations.additional_properties["description"] or "",
+        tags=annotations.tags,
+        properties=properties.additional_properties["userProperties"],
+        experiment_name=properties.additional_properties["experimentName"],
+        services={},
+        status=annotations.additional_properties["status"],
+        creation_context=creation_context,
+        compute=(
+            properties.additional_properties["compute"]["armId"]
+            if "compute" in properties.additional_properties
+            else None
+        ),
+    )
+
+
+__all__ = [
+    "IndexServiceAPIs",
+    "CrossRegionIndexEntitiesRequest",
+    "IndexEntitiesRequest",
+    "IndexEntitiesRequestFilter",
+    "IndexEntitiesRequestOrder",
+    "IndexEntitiesRequestOrderDirection",
+    "index_entity_response_to_job",
+]
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/__init__.py
new file mode 100644
index 00000000..29a4fcd3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/__init__.py
@@ -0,0 +1,5 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/__init__.py
new file mode 100644
index 00000000..bbe9c82c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/__init__.py
@@ -0,0 +1,17 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._index_service_apis import IndexServiceAPIs
+from ._version import VERSION
+
+__version__ = VERSION
+__all__ = ["IndexServiceAPIs"]
+
+# `._patch.py` is used for handwritten extensions to the generated code
+# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
+from ._patch import patch_sdk
+
+patch_sdk()
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_configuration.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_configuration.py
new file mode 100644
index 00000000..abe36f8c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_configuration.py
@@ -0,0 +1,63 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from typing import TYPE_CHECKING
+
+from azure.core.configuration import Configuration
+from azure.core.pipeline import policies
+from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy
+
+from ._version import VERSION
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from typing import Any
+
+    from azure.core.credentials import TokenCredential
+
+
+class IndexServiceAPIsConfiguration(Configuration):  # pylint: disable=too-many-instance-attributes
+    """Configuration for IndexServiceAPIs.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+
+    :param credential: Credential needed for the client to connect to Azure.
+    :type credential: ~azure.core.credentials.TokenCredential
+    """
+
+    def __init__(
+        self,
+        credential,  # type: "TokenCredential"
+        **kwargs  # type: Any
+    ):
+        # type: (...) -> None
+        super(IndexServiceAPIsConfiguration, self).__init__(**kwargs)
+        if credential is None:
+            raise ValueError("Parameter 'credential' must not be None.")
+
+        self.credential = credential
+        self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"])
+        kwargs.setdefault("sdk_moniker", "indexserviceapis/{}".format(VERSION))
+        self._configure(**kwargs)
+
+    def _configure(
+        self, **kwargs  # type: Any
+    ):
+        # type: (...) -> None
+        self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs)
+        self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs)
+        self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
+        self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs)
+        self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
+        self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
+        self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs)
+        self.authentication_policy = kwargs.get("authentication_policy")
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = ARMChallengeAuthenticationPolicy(
+                self.credential, *self.credential_scopes, **kwargs
+            )
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_index_service_apis.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_index_service_apis.py
new file mode 100644
index 00000000..c0d3b3bf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_index_service_apis.py
@@ -0,0 +1,91 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from copy import deepcopy
+from typing import TYPE_CHECKING
+
+from msrest import Deserializer, Serializer
+
+from azure.mgmt.core import ARMPipelineClient
+
+from . import models
+from ._configuration import IndexServiceAPIsConfiguration
+from .operations import IndexEntitiesOperations
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from typing import Any
+
+    from azure.core.credentials import TokenCredential
+    from azure.core.rest import HttpRequest, HttpResponse
+
+
+class IndexServiceAPIs(object):
+    """IndexServiceAPIs.
+
+    :ivar index_entities: IndexEntitiesOperations operations
+    :vartype index_entities: index_service_apis.operations.IndexEntitiesOperations
+    :param credential: Credential needed for the client to connect to Azure.
+    :type credential: ~azure.core.credentials.TokenCredential
+    :param base_url: Service URL. Default value is ''.
+    :type base_url: str
+    """
+
+    def __init__(
+        self,
+        credential,  # type: "TokenCredential"
+        base_url="",  # type: str
+        **kwargs  # type: Any
+    ):
+        # type: (...) -> None
+        self._config = IndexServiceAPIsConfiguration(credential=credential, **kwargs)
+        self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
+
+        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
+        self._serialize = Serializer(client_models)
+        self._deserialize = Deserializer(client_models)
+        self._serialize.client_side_validation = False
+        self.index_entities = IndexEntitiesOperations(self._client, self._config, self._serialize, self._deserialize)
+
+    def _send_request(
+        self,
+        request,  # type: HttpRequest
+        **kwargs  # type: Any
+    ):
+        # type: (...) -> HttpResponse
+        """Runs the network request through the client's chained policies.
+
+        >>> from azure.core.rest import HttpRequest
+        >>> request = HttpRequest("GET", "https://www.example.org/")
+        <HttpRequest [GET], url: 'https://www.example.org/'>
+        >>> response = client._send_request(request)
+        <HttpResponse: 200 OK>
+
+        For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
+
+        :param request: The network request you want to make. Required.
+        :type request: ~azure.core.rest.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to False.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.rest.HttpResponse
+        """
+
+        request_copy = deepcopy(request)
+        request_copy.url = self._client.format_url(request_copy.url)
+        return self._client.send_request(request_copy, **kwargs)
+
+    def close(self):
+        # type: () -> None
+        self._client.close()
+
+    def __enter__(self):
+        # type: () -> IndexServiceAPIs
+        self._client.__enter__()
+        return self
+
+    def __exit__(self, *exc_details):
+        # type: (Any) -> None
+        self._client.__exit__(*exc_details)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_patch.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_patch.py
new file mode 100644
index 00000000..17dbc073
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_patch.py
@@ -0,0 +1,32 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the ""Software""), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+# --------------------------------------------------------------------------
+
+
+# This file is used for handwritten extensions to the generated code. Example:
+# https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
+def patch_sdk():
+    pass
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_vendor.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_vendor.py
new file mode 100644
index 00000000..cc6e8179
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_vendor.py
@@ -0,0 +1,14 @@
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from azure.core.pipeline.transport import HttpRequest
+
+
+def _convert_request(request, files=None):
+    data = request.content if not files else None
+    request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
+    if files:
+        request.set_formdata_body(files)
+    return request
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_version.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_version.py
new file mode 100644
index 00000000..c45fe3b0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_version.py
@@ -0,0 +1,7 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+VERSION = "0.1.0"
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/__init__.py
new file mode 100644
index 00000000..a22bc3dd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/__init__.py
@@ -0,0 +1,15 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._index_service_apis import IndexServiceAPIs
+
+__all__ = ["IndexServiceAPIs"]
+
+# `._patch.py` is used for handwritten extensions to the generated code
+# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
+from ._patch import patch_sdk
+
+patch_sdk()
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_configuration.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_configuration.py
new file mode 100644
index 00000000..1476e175
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_configuration.py
@@ -0,0 +1,53 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from typing import Any, TYPE_CHECKING
+
+from azure.core.configuration import Configuration
+from azure.core.pipeline import policies
+from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy
+
+from .._version import VERSION
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core.credentials_async import AsyncTokenCredential
+
+
+class IndexServiceAPIsConfiguration(Configuration):  # pylint: disable=too-many-instance-attributes
+    """Configuration for IndexServiceAPIs.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+
+    :param credential: Credential needed for the client to connect to Azure.
+    :type credential: ~azure.core.credentials_async.AsyncTokenCredential
+    """
+
+    def __init__(self, credential: "AsyncTokenCredential", **kwargs: Any) -> None:
+        super(IndexServiceAPIsConfiguration, self).__init__(**kwargs)
+        if credential is None:
+            raise ValueError("Parameter 'credential' must not be None.")
+
+        self.credential = credential
+        self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"])
+        kwargs.setdefault("sdk_moniker", "indexserviceapis/{}".format(VERSION))
+        self._configure(**kwargs)
+
+    def _configure(self, **kwargs: Any) -> None:
+        self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs)
+        self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs)
+        self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
+        self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs)
+        self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs)
+        self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
+        self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs)
+        self.authentication_policy = kwargs.get("authentication_policy")
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = AsyncARMChallengeAuthenticationPolicy(
+                self.credential, *self.credential_scopes, **kwargs
+            )
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_index_service_apis.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_index_service_apis.py
new file mode 100644
index 00000000..33a8eca6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_index_service_apis.py
@@ -0,0 +1,75 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from copy import deepcopy
+from typing import Any, Awaitable, TYPE_CHECKING
+
+from msrest import Deserializer, Serializer
+
+from azure.core.rest import AsyncHttpResponse, HttpRequest
+from azure.mgmt.core import AsyncARMPipelineClient
+
+from .. import models
+from ._configuration import IndexServiceAPIsConfiguration
+from .operations import IndexEntitiesOperations
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core.credentials_async import AsyncTokenCredential
+
+
+class IndexServiceAPIs:
+    """IndexServiceAPIs.
+
+    :ivar index_entities: IndexEntitiesOperations operations
+    :vartype index_entities: index_service_apis.aio.operations.IndexEntitiesOperations
+    :param credential: Credential needed for the client to connect to Azure.
+    :type credential: ~azure.core.credentials_async.AsyncTokenCredential
+    :param base_url: Service URL. Default value is ''.
+    :type base_url: str
+    """
+
+    def __init__(self, credential: "AsyncTokenCredential", base_url: str = "", **kwargs: Any) -> None:
+        self._config = IndexServiceAPIsConfiguration(credential=credential, **kwargs)
+        self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
+
+        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
+        self._serialize = Serializer(client_models)
+        self._deserialize = Deserializer(client_models)
+        self._serialize.client_side_validation = False
+        self.index_entities = IndexEntitiesOperations(self._client, self._config, self._serialize, self._deserialize)
+
+    def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]:
+        """Runs the network request through the client's chained policies.
+
+        >>> from azure.core.rest import HttpRequest
+        >>> request = HttpRequest("GET", "https://www.example.org/")
+        <HttpRequest [GET], url: 'https://www.example.org/'>
+        >>> response = await client._send_request(request)
+        <AsyncHttpResponse: 200 OK>
+
+        For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
+
+        :param request: The network request you want to make. Required.
+        :type request: ~azure.core.rest.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to False.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.rest.AsyncHttpResponse
+        """
+
+        request_copy = deepcopy(request)
+        request_copy.url = self._client.format_url(request_copy.url)
+        return self._client.send_request(request_copy, **kwargs)
+
+    async def close(self) -> None:
+        await self._client.close()
+
+    async def __aenter__(self) -> "IndexServiceAPIs":
+        await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, *exc_details) -> None:
+        await self._client.__aexit__(*exc_details)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_patch.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_patch.py
new file mode 100644
index 00000000..17dbc073
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_patch.py
@@ -0,0 +1,32 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the ""Software""), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+# --------------------------------------------------------------------------
+
+
+# This file is used for handwritten extensions to the generated code. Example:
+# https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
+def patch_sdk():
+    pass
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/__init__.py
new file mode 100644
index 00000000..19ac2fed
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/__init__.py
@@ -0,0 +1,11 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._index_entities_operations import IndexEntitiesOperations
+
+__all__ = [
+    "IndexEntitiesOperations",
+]
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/_index_entities_operations.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/_index_entities_operations.py
new file mode 100644
index 00000000..b38a0dcb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/_index_entities_operations.py
@@ -0,0 +1,128 @@
+# pylint: disable=too-many-lines
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar
+
+from azure.core.async_paging import AsyncItemPaged, AsyncList
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceExistsError,
+    ResourceNotFoundError,
+    map_error,
+)
+from azure.core.pipeline import PipelineResponse
+from azure.core.pipeline.transport import AsyncHttpResponse
+from azure.core.rest import HttpRequest
+from azure.core.tracing.decorator import distributed_trace
+from azure.mgmt.core.exceptions import ARMErrorFormat
+
+from ... import models as _models
+from ..._vendor import _convert_request
+from ...operations._index_entities_operations import build_get_entites_cross_region_request
+
+T = TypeVar("T")
+ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
+
+
+class IndexEntitiesOperations:
+    """IndexEntitiesOperations async operations.
+
+    You should not instantiate this class directly. Instead, you should create a Client instance that
+    instantiates it for you and attaches it as an attribute.
+
+    :ivar models: Alias to model classes used in this operation group.
+    :type models: ~index_service_apis.models
+    :param client: Client for service requests.
+    :param config: Configuration of service client.
+    :param serializer: An object model serializer.
+    :param deserializer: An object model deserializer.
+    """
+
+    models = _models
+
+    def __init__(self, client, config, serializer, deserializer) -> None:
+        self._client = client
+        self._serialize = serializer
+        self._deserialize = deserializer
+        self._config = config
+
+    @distributed_trace
+    def get_entites_cross_region(
+        self, body: Optional["_models.CrossRegionIndexEntitiesRequest"] = None, **kwargs: Any
+    ) -> AsyncIterable["_models.IndexEntitiesResponse"]:
+        """get_entites_cross_region.
+
+        :param body:
+        :type body: ~index_service_apis.models.CrossRegionIndexEntitiesRequest
+        :keyword callable cls: A custom type or function that will be passed the direct response
+        :return: An iterator like instance of either IndexEntitiesResponse or the result of
+         cls(response)
+        :rtype:
+         ~azure.core.async_paging.AsyncItemPaged[~index_service_apis.models.IndexEntitiesResponse]
+        :raises: ~azure.core.exceptions.HttpResponseError
+        """
+        content_type = kwargs.pop("content_type", "application/json-patch+json")  # type: Optional[str]
+
+        cls = kwargs.pop("cls", None)  # type: ClsType["_models.IndexEntitiesResponse"]
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}))
+
+        def prepare_request(next_link=None):
+            if not next_link:
+                if body is not None:
+                    _json = self._serialize.body(body, "CrossRegionIndexEntitiesRequest")
+                else:
+                    _json = None
+
+                request = build_get_entites_cross_region_request(
+                    content_type=content_type,
+                    json=_json,
+                    template_url=self.get_entites_cross_region.metadata["url"],
+                )
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)
+
+            else:
+                if body is not None:
+                    _json = self._serialize.body(body, "CrossRegionIndexEntitiesRequest")
+                else:
+                    _json = None
+
+                request = build_get_entites_cross_region_request(
+                    content_type=content_type,
+                    json=_json,
+                    template_url=next_link,
+                )
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)
+                request.method = "GET"
+            return request
+
+        async def extract_data(pipeline_response):
+            deserialized = self._deserialize("IndexEntitiesResponse", pipeline_response)
+            list_of_elem = deserialized.value
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            return None, AsyncList(list_of_elem)
+
+        async def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, error_format=ARMErrorFormat)
+
+            return pipeline_response
+
+        return AsyncItemPaged(get_next, extract_data)
+
+    get_entites_cross_region.metadata = {"url": "/ux/v1.0/entities/crossRegion"}  # type: ignore
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/__init__.py
new file mode 100644
index 00000000..7e5d9a66
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/__init__.py
@@ -0,0 +1,517 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+try:
+    from ._models_py3 import BatchEndpointAnnotations
+    from ._models_py3 import BatchEndpointProperties
+    from ._models_py3 import BatchendpointsUnversionedEntitiesResponse
+    from ._models_py3 import BatchendpointsUnversionedEntity
+    from ._models_py3 import Compute
+    from ._models_py3 import ComputeRequest
+    from ._models_py3 import ContainerResourceRequirements
+    from ._models_py3 import ControlOutput
+    from ._models_py3 import CreatedBy
+    from ._models_py3 import CreatedBy1
+    from ._models_py3 import CreationContext
+    from ._models_py3 import CronTrigger
+    from ._models_py3 import CrossRegionIndexEntitiesRequest
+    from ._models_py3 import CrossRegionIndexEntitiesResponse
+    from ._models_py3 import CudaAttribute
+    from ._models_py3 import DataStoreAnnotations
+    from ._models_py3 import DataStoreProperties
+    from ._models_py3 import DatasetAnnotations
+    from ._models_py3 import DatasetProperties
+    from ._models_py3 import DatasetReference
+    from ._models_py3 import DatasetsVersionedEntitiesResponse
+    from ._models_py3 import DatasetsVersionedEntity
+    from ._models_py3 import DatastoresUnversionedEntitiesResponse
+    from ._models_py3 import DatastoresUnversionedEntity
+    from ._models_py3 import DebugInfoResponse
+    from ._models_py3 import DefinitionAnnotations
+    from ._models_py3 import DefinitionProperties
+    from ._models_py3 import EndpointComputeTarget
+    from ._models_py3 import EnvironmentAttributes
+    from ._models_py3 import EnvironmentsVersionedEntitiesResponse
+    from ._models_py3 import EnvironmentsVersionedEntity
+    from ._models_py3 import ErrorAdditionalInfo
+    from ._models_py3 import ErrorResponse
+    from ._models_py3 import ExperimentStatus
+    from ._models_py3 import Feature
+    from ._models_py3 import FeatureEntityVersionAnnotations
+    from ._models_py3 import FeatureEntityVersionProperties
+    from ._models_py3 import FeatureSetVersionAnnotations
+    from ._models_py3 import FeatureSetVersionProperties
+    from ._models_py3 import FeatureSourceDto
+    from ._models_py3 import FeatureTransformationDto
+    from ._models_py3 import FeatureentitiesVersionedEntitiesResponse
+    from ._models_py3 import FeatureentitiesVersionedEntity
+    from ._models_py3 import FeaturesetSpecification
+    from ._models_py3 import FeaturesetsVersionedEntitiesResponse
+    from ._models_py3 import FeaturesetsVersionedEntity
+    from ._models_py3 import FeaturestoreentitiesVersionedEntitiesResponse
+    from ._models_py3 import FeaturestoreentitiesVersionedEntity
+    from ._models_py3 import FreeTextSearchColumn
+    from ._models_py3 import GenericTriggerAnnotations
+    from ._models_py3 import GenericTriggerProperties
+    from ._models_py3 import GenerictriggersUnversionedEntitiesResponse
+    from ._models_py3 import GenerictriggersUnversionedEntity
+    from ._models_py3 import HighlightOptions
+    from ._models_py3 import IndependentPipelineAnnotations
+    from ._models_py3 import IndependentPipelineProperties
+    from ._models_py3 import IndependentpipelinesUnversionedEntitiesResponse
+    from ._models_py3 import IndependentpipelinesUnversionedEntity
+    from ._models_py3 import IndexAnnotations
+    from ._models_py3 import IndexColumn
+    from ._models_py3 import IndexColumnDto
+    from ._models_py3 import IndexEntitiesLocalOperationRequest
+    from ._models_py3 import IndexEntitiesRequest
+    from ._models_py3 import IndexEntitiesRequestFilter
+    from ._models_py3 import IndexEntitiesRequestGroup
+    from ._models_py3 import IndexEntitiesRequestOrder
+    from ._models_py3 import IndexEntitiesResponse
+    from ._models_py3 import IndexEntityContainerMetadata
+    from ._models_py3 import IndexEntityResponse
+    from ._models_py3 import IndexProperties
+    from ._models_py3 import IndexResourceDiscoveryResponseItem
+    from ._models_py3 import IndexResourceDiscoveryResponseItemPaginatedResult
+    from ._models_py3 import IndexedErrorResponse
+    from ._models_py3 import InnerErrorResponse
+    from ._models_py3 import InputNameAndDataTypeIdsList
+    from ._models_py3 import InternalUxPresenceWarmUpRequest
+    from ._models_py3 import JobCost
+    from ._models_py3 import MaterializationComputeResource
+    from ._models_py3 import MaterializationSettings
+    from ._models_py3 import ModelAnnotations
+    from ._models_py3 import ModelProperties
+    from ._models_py3 import ModelsVersionedEntitiesResponse
+    from ._models_py3 import ModelsVersionedEntity
+    from ._models_py3 import ModuleAnnotations
+    from ._models_py3 import ModuleProperties
+    from ._models_py3 import ModulesVersionedEntitiesResponse
+    from ._models_py3 import ModulesVersionedEntity
+    from ._models_py3 import NotificationSetting
+    from ._models_py3 import OnlineEndpointAnnotations
+    from ._models_py3 import OnlineEndpointProperties
+    from ._models_py3 import OnlineendpointsUnversionedEntitiesResponse
+    from ._models_py3 import OnlineendpointsUnversionedEntity
+    from ._models_py3 import OutputNameAndDataTypeId
+    from ._models_py3 import PipelineAnnotations
+    from ._models_py3 import PipelineDraftAnnotations
+    from ._models_py3 import PipelineDraftProperties
+    from ._models_py3 import PipelineProperties
+    from ._models_py3 import PipelineRunAnnotations
+    from ._models_py3 import PipelineRunProperties
+    from ._models_py3 import PipelinedraftsUnversionedEntitiesResponse
+    from ._models_py3 import PipelinedraftsUnversionedEntity
+    from ._models_py3 import PipelinerunsUnversionedEntitiesResponse
+    from ._models_py3 import PipelinerunsUnversionedEntity
+    from ._models_py3 import PipelinesVersionedEntitiesResponse
+    from ._models_py3 import PipelinesVersionedEntity
+    from ._models_py3 import Purpose
+    from ._models_py3 import Recurrence
+    from ._models_py3 import RecurrenceSchedule
+    from ._models_py3 import RecurrenceTrigger
+    from ._models_py3 import Relationship
+    from ._models_py3 import ResourceDiscoveryContainerMetadata
+    from ._models_py3 import ResourceDiscoveryContainerMetadataPaginatedResult
+    from ._models_py3 import ResourceDiscoveryRequest
+    from ._models_py3 import ResourceInformation
+    from ._models_py3 import ResourceRegion
+    from ._models_py3 import RootError
+    from ._models_py3 import RunAnnotations
+    from ._models_py3 import RunIndexMetricSummaryJValue
+    from ._models_py3 import RunIndexMetricSummaryObject
+    from ._models_py3 import RunIndexResourceMetricSummary
+    from ._models_py3 import RunProperties
+    from ._models_py3 import RunTypeV2Index
+    from ._models_py3 import RunsUnversionedEntitiesResponse
+    from ._models_py3 import RunsUnversionedEntity
+    from ._models_py3 import SingleShardFanoutData
+    from ._models_py3 import StringContainsRequest
+    from ._models_py3 import StructuredInterfaceParameter
+    from ._models_py3 import TimeDeltaDto
+    from ._models_py3 import TimestampColumnDto
+    from ._models_py3 import UnqueriableResourcesScope
+    from ._models_py3 import Usage
+    from ._models_py3 import UserDto
+    from ._models_py3 import UxPresenceResource
+    from ._models_py3 import UxWarmUpRequest
+    from ._models_py3 import VersionedAttribute
+    from ._models_py3 import Webhook
+    from ._models_py3 import WorkspaceContextWarmUpRequest
+except (SyntaxError, ImportError):
+    from ._models import BatchEndpointAnnotations  # type: ignore
+    from ._models import BatchEndpointProperties  # type: ignore
+    from ._models import BatchendpointsUnversionedEntitiesResponse  # type: ignore
+    from ._models import BatchendpointsUnversionedEntity  # type: ignore
+    from ._models import Compute  # type: ignore
+    from ._models import ComputeRequest  # type: ignore
+    from ._models import ContainerResourceRequirements  # type: ignore
+    from ._models import ControlOutput  # type: ignore
+    from ._models import CreatedBy  # type: ignore
+    from ._models import CreatedBy1  # type: ignore
+    from ._models import CreationContext  # type: ignore
+    from ._models import CronTrigger  # type: ignore
+    from ._models import CrossRegionIndexEntitiesRequest  # type: ignore
+    from ._models import CrossRegionIndexEntitiesResponse  # type: ignore
+    from ._models import CudaAttribute  # type: ignore
+    from ._models import DataStoreAnnotations  # type: ignore
+    from ._models import DataStoreProperties  # type: ignore
+    from ._models import DatasetAnnotations  # type: ignore
+    from ._models import DatasetProperties  # type: ignore
+    from ._models import DatasetReference  # type: ignore
+    from ._models import DatasetsVersionedEntitiesResponse  # type: ignore
+    from ._models import DatasetsVersionedEntity  # type: ignore
+    from ._models import DatastoresUnversionedEntitiesResponse  # type: ignore
+    from ._models import DatastoresUnversionedEntity  # type: ignore
+    from ._models import DebugInfoResponse  # type: ignore
+    from ._models import DefinitionAnnotations  # type: ignore
+    from ._models import DefinitionProperties  # type: ignore
+    from ._models import EndpointComputeTarget  # type: ignore
+    from ._models import EnvironmentAttributes  # type: ignore
+    from ._models import EnvironmentsVersionedEntitiesResponse  # type: ignore
+    from ._models import EnvironmentsVersionedEntity  # type: ignore
+    from ._models import ErrorAdditionalInfo  # type: ignore
+    from ._models import ErrorResponse  # type: ignore
+    from ._models import ExperimentStatus  # type: ignore
+    from ._models import Feature  # type: ignore
+    from ._models import FeatureEntityVersionAnnotations  # type: ignore
+    from ._models import FeatureEntityVersionProperties  # type: ignore
+    from ._models import FeatureSetVersionAnnotations  # type: ignore
+    from ._models import FeatureSetVersionProperties  # type: ignore
+    from ._models import FeatureSourceDto  # type: ignore
+    from ._models import FeatureTransformationDto  # type: ignore
+    from ._models import FeatureentitiesVersionedEntitiesResponse  # type: ignore
+    from ._models import FeatureentitiesVersionedEntity  # type: ignore
+    from ._models import FeaturesetSpecification  # type: ignore
+    from ._models import FeaturesetsVersionedEntitiesResponse  # type: ignore
+    from ._models import FeaturesetsVersionedEntity  # type: ignore
+    from ._models import FeaturestoreentitiesVersionedEntitiesResponse  # type: ignore
+    from ._models import FeaturestoreentitiesVersionedEntity  # type: ignore
+    from ._models import FreeTextSearchColumn  # type: ignore
+    from ._models import GenericTriggerAnnotations  # type: ignore
+    from ._models import GenericTriggerProperties  # type: ignore
+    from ._models import GenerictriggersUnversionedEntitiesResponse  # type: ignore
+    from ._models import GenerictriggersUnversionedEntity  # type: ignore
+    from ._models import HighlightOptions  # type: ignore
+    from ._models import IndependentPipelineAnnotations  # type: ignore
+    from ._models import IndependentPipelineProperties  # type: ignore
+    from ._models import IndependentpipelinesUnversionedEntitiesResponse  # type: ignore
+    from ._models import IndependentpipelinesUnversionedEntity  # type: ignore
+    from ._models import IndexAnnotations  # type: ignore
+    from ._models import IndexColumn  # type: ignore
+    from ._models import IndexColumnDto  # type: ignore
+    from ._models import IndexEntitiesLocalOperationRequest  # type: ignore
+    from ._models import IndexEntitiesRequest  # type: ignore
+    from ._models import IndexEntitiesRequestFilter  # type: ignore
+    from ._models import IndexEntitiesRequestGroup  # type: ignore
+    from ._models import IndexEntitiesRequestOrder  # type: ignore
+    from ._models import IndexEntitiesResponse  # type: ignore
+    from ._models import IndexEntityContainerMetadata  # type: ignore
+    from ._models import IndexEntityResponse  # type: ignore
+    from ._models import IndexProperties  # type: ignore
+    from ._models import IndexResourceDiscoveryResponseItem  # type: ignore
+    from ._models import IndexResourceDiscoveryResponseItemPaginatedResult  # type: ignore
+    from ._models import IndexedErrorResponse  # type: ignore
+    from ._models import InnerErrorResponse  # type: ignore
+    from ._models import InputNameAndDataTypeIdsList  # type: ignore
+    from ._models import InternalUxPresenceWarmUpRequest  # type: ignore
+    from ._models import JobCost  # type: ignore
+    from ._models import MaterializationComputeResource  # type: ignore
+    from ._models import MaterializationSettings  # type: ignore
+    from ._models import ModelAnnotations  # type: ignore
+    from ._models import ModelProperties  # type: ignore
+    from ._models import ModelsVersionedEntitiesResponse  # type: ignore
+    from ._models import ModelsVersionedEntity  # type: ignore
+    from ._models import ModuleAnnotations  # type: ignore
+    from ._models import ModuleProperties  # type: ignore
+    from ._models import ModulesVersionedEntitiesResponse  # type: ignore
+    from ._models import ModulesVersionedEntity  # type: ignore
+    from ._models import NotificationSetting  # type: ignore
+    from ._models import OnlineEndpointAnnotations  # type: ignore
+    from ._models import OnlineEndpointProperties  # type: ignore
+    from ._models import OnlineendpointsUnversionedEntitiesResponse  # type: ignore
+    from ._models import OnlineendpointsUnversionedEntity  # type: ignore
+    from ._models import OutputNameAndDataTypeId  # type: ignore
+    from ._models import PipelineAnnotations  # type: ignore
+    from ._models import PipelineDraftAnnotations  # type: ignore
+    from ._models import PipelineDraftProperties  # type: ignore
+    from ._models import PipelineProperties  # type: ignore
+    from ._models import PipelineRunAnnotations  # type: ignore
+    from ._models import PipelineRunProperties  # type: ignore
+    from ._models import PipelinedraftsUnversionedEntitiesResponse  # type: ignore
+    from ._models import PipelinedraftsUnversionedEntity  # type: ignore
+    from ._models import PipelinerunsUnversionedEntitiesResponse  # type: ignore
+    from ._models import PipelinerunsUnversionedEntity  # type: ignore
+    from ._models import PipelinesVersionedEntitiesResponse  # type: ignore
+    from ._models import PipelinesVersionedEntity  # type: ignore
+    from ._models import Purpose  # type: ignore
+    from ._models import Recurrence  # type: ignore
+    from ._models import RecurrenceSchedule  # type: ignore
+    from ._models import RecurrenceTrigger  # type: ignore
+    from ._models import Relationship  # type: ignore
+    from ._models import ResourceDiscoveryContainerMetadata  # type: ignore
+    from ._models import ResourceDiscoveryContainerMetadataPaginatedResult  # type: ignore
+    from ._models import ResourceDiscoveryRequest  # type: ignore
+    from ._models import ResourceInformation  # type: ignore
+    from ._models import ResourceRegion  # type: ignore
+    from ._models import RootError  # type: ignore
+    from ._models import RunAnnotations  # type: ignore
+    from ._models import RunIndexMetricSummaryJValue  # type: ignore
+    from ._models import RunIndexMetricSummaryObject  # type: ignore
+    from ._models import RunIndexResourceMetricSummary  # type: ignore
+    from ._models import RunProperties  # type: ignore
+    from ._models import RunTypeV2Index  # type: ignore
+    from ._models import RunsUnversionedEntitiesResponse  # type: ignore
+    from ._models import RunsUnversionedEntity  # type: ignore
+    from ._models import SingleShardFanoutData  # type: ignore
+    from ._models import StringContainsRequest  # type: ignore
+    from ._models import StructuredInterfaceParameter  # type: ignore
+    from ._models import TimeDeltaDto  # type: ignore
+    from ._models import TimestampColumnDto  # type: ignore
+    from ._models import UnqueriableResourcesScope  # type: ignore
+    from ._models import Usage  # type: ignore
+    from ._models import UserDto  # type: ignore
+    from ._models import UxPresenceResource  # type: ignore
+    from ._models import UxWarmUpRequest  # type: ignore
+    from ._models import VersionedAttribute  # type: ignore
+    from ._models import Webhook  # type: ignore
+    from ._models import WorkspaceContextWarmUpRequest  # type: ignore
+
+from ._index_service_apis_enums import (
+    AssetContainerTypeFeedRename,
+    BatchendpointsUnversionedEntityKind,
+    DataStoreAnnotationsDataStoreType,
+    DatasetsVersionedEntityKind,
+    DatastoresUnversionedEntityKind,
+    EntityKind,
+    EnvironmentsVersionedEntityKind,
+    ExperimentStatusCode,
+    FeatureDataType,
+    FeatureSourceDtoType,
+    FeatureentitiesVersionedEntityKind,
+    FeaturesetsVersionedEntityKind,
+    FeaturestoreentitiesVersionedEntityKind,
+    GenericTriggerAnnotationsEntityStatus,
+    GenericTriggerAnnotationsManagedType,
+    GenericTriggerAnnotationsProvisioningStatus,
+    GenericTriggerAnnotationsScheduleActionType,
+    GenericTriggerAnnotationsScheduleMethod,
+    GenericTriggerAnnotationsTriggerType,
+    GenerictriggersUnversionedEntityKind,
+    IndependentPipelineAnnotationsEntityStatus,
+    IndependentPipelineAnnotationsLastRunStatusCode,
+    IndependentpipelinesUnversionedEntityKind,
+    IndexColumnDataType,
+    IndexColumnDtoType,
+    IndexEntitiesRequestOrderDirection,
+    MaterializationSettingsMaterializationStoreType,
+    ModelsVersionedEntityKind,
+    ModuleAnnotationsAmlModuleEntityStatus,
+    ModuleAnnotationsEntityStatus,
+    ModuleAnnotationsModuleType,
+    ModulesVersionedEntityKind,
+    NotificationSettingEmailOnItem,
+    OnlineendpointsUnversionedEntityKind,
+    PipelineAnnotationsEntityStatus,
+    PipelineAnnotationsLastRunStatusCode,
+    PipelineDraftAnnotationsEntityStatus,
+    PipelineRunAnnotationsEntityStatus,
+    PipelinedraftsUnversionedEntityKind,
+    PipelinerunsUnversionedEntityKind,
+    PipelinesVersionedEntityKind,
+    RecurrenceFrequency,
+    RecurrenceScheduleWeekDaysItem,
+    RecurrenceTriggerFrequency,
+    RunsUnversionedEntityKind,
+    StructuredInterfaceParameterType,
+)
+
+__all__ = [
+    "BatchEndpointAnnotations",
+    "BatchEndpointProperties",
+    "BatchendpointsUnversionedEntitiesResponse",
+    "BatchendpointsUnversionedEntity",
+    "Compute",
+    "ComputeRequest",
+    "ContainerResourceRequirements",
+    "ControlOutput",
+    "CreatedBy",
+    "CreatedBy1",
+    "CreationContext",
+    "CronTrigger",
+    "CrossRegionIndexEntitiesRequest",
+    "CrossRegionIndexEntitiesResponse",
+    "CudaAttribute",
+    "DataStoreAnnotations",
+    "DataStoreProperties",
+    "DatasetAnnotations",
+    "DatasetProperties",
+    "DatasetReference",
+    "DatasetsVersionedEntitiesResponse",
+    "DatasetsVersionedEntity",
+    "DatastoresUnversionedEntitiesResponse",
+    "DatastoresUnversionedEntity",
+    "DebugInfoResponse",
+    "DefinitionAnnotations",
+    "DefinitionProperties",
+    "EndpointComputeTarget",
+    "EnvironmentAttributes",
+    "EnvironmentsVersionedEntitiesResponse",
+    "EnvironmentsVersionedEntity",
+    "ErrorAdditionalInfo",
+    "ErrorResponse",
+    "ExperimentStatus",
+    "Feature",
+    "FeatureEntityVersionAnnotations",
+    "FeatureEntityVersionProperties",
+    "FeatureSetVersionAnnotations",
+    "FeatureSetVersionProperties",
+    "FeatureSourceDto",
+    "FeatureTransformationDto",
+    "FeatureentitiesVersionedEntitiesResponse",
+    "FeatureentitiesVersionedEntity",
+    "FeaturesetSpecification",
+    "FeaturesetsVersionedEntitiesResponse",
+    "FeaturesetsVersionedEntity",
+    "FeaturestoreentitiesVersionedEntitiesResponse",
+    "FeaturestoreentitiesVersionedEntity",
+    "FreeTextSearchColumn",
+    "GenericTriggerAnnotations",
+    "GenericTriggerProperties",
+    "GenerictriggersUnversionedEntitiesResponse",
+    "GenerictriggersUnversionedEntity",
+    "HighlightOptions",
+    "IndependentPipelineAnnotations",
+    "IndependentPipelineProperties",
+    "IndependentpipelinesUnversionedEntitiesResponse",
+    "IndependentpipelinesUnversionedEntity",
+    "IndexAnnotations",
+    "IndexColumn",
+    "IndexColumnDto",
+    "IndexEntitiesLocalOperationRequest",
+    "IndexEntitiesRequest",
+    "IndexEntitiesRequestFilter",
+    "IndexEntitiesRequestGroup",
+    "IndexEntitiesRequestOrder",
+    "IndexEntitiesResponse",
+    "IndexEntityContainerMetadata",
+    "IndexEntityResponse",
+    "IndexProperties",
+    "IndexResourceDiscoveryResponseItem",
+    "IndexResourceDiscoveryResponseItemPaginatedResult",
+    "IndexedErrorResponse",
+    "InnerErrorResponse",
+    "InputNameAndDataTypeIdsList",
+    "InternalUxPresenceWarmUpRequest",
+    "JobCost",
+    "MaterializationComputeResource",
+    "MaterializationSettings",
+    "ModelAnnotations",
+    "ModelProperties",
+    "ModelsVersionedEntitiesResponse",
+    "ModelsVersionedEntity",
+    "ModuleAnnotations",
+    "ModuleProperties",
+    "ModulesVersionedEntitiesResponse",
+    "ModulesVersionedEntity",
+    "NotificationSetting",
+    "OnlineEndpointAnnotations",
+    "OnlineEndpointProperties",
+    "OnlineendpointsUnversionedEntitiesResponse",
+    "OnlineendpointsUnversionedEntity",
+    "OutputNameAndDataTypeId",
+    "PipelineAnnotations",
+    "PipelineDraftAnnotations",
+    "PipelineDraftProperties",
+    "PipelineProperties",
+    "PipelineRunAnnotations",
+    "PipelineRunProperties",
+    "PipelinedraftsUnversionedEntitiesResponse",
+    "PipelinedraftsUnversionedEntity",
+    "PipelinerunsUnversionedEntitiesResponse",
+    "PipelinerunsUnversionedEntity",
+    "PipelinesVersionedEntitiesResponse",
+    "PipelinesVersionedEntity",
+    "Purpose",
+    "Recurrence",
+    "RecurrenceSchedule",
+    "RecurrenceTrigger",
+    "Relationship",
+    "ResourceDiscoveryContainerMetadata",
+    "ResourceDiscoveryContainerMetadataPaginatedResult",
+    "ResourceDiscoveryRequest",
+    "ResourceInformation",
+    "ResourceRegion",
+    "RootError",
+    "RunAnnotations",
+    "RunIndexMetricSummaryJValue",
+    "RunIndexMetricSummaryObject",
+    "RunIndexResourceMetricSummary",
+    "RunProperties",
+    "RunTypeV2Index",
+    "RunsUnversionedEntitiesResponse",
+    "RunsUnversionedEntity",
+    "SingleShardFanoutData",
+    "StringContainsRequest",
+    "StructuredInterfaceParameter",
+    "TimeDeltaDto",
+    "TimestampColumnDto",
+    "UnqueriableResourcesScope",
+    "Usage",
+    "UserDto",
+    "UxPresenceResource",
+    "UxWarmUpRequest",
+    "VersionedAttribute",
+    "Webhook",
+    "WorkspaceContextWarmUpRequest",
+    "AssetContainerTypeFeedRename",
+    "BatchendpointsUnversionedEntityKind",
+    "DataStoreAnnotationsDataStoreType",
+    "DatasetsVersionedEntityKind",
+    "DatastoresUnversionedEntityKind",
+    "EntityKind",
+    "EnvironmentsVersionedEntityKind",
+    "ExperimentStatusCode",
+    "FeatureDataType",
+    "FeatureSourceDtoType",
+    "FeatureentitiesVersionedEntityKind",
+    "FeaturesetsVersionedEntityKind",
+    "FeaturestoreentitiesVersionedEntityKind",
+    "GenericTriggerAnnotationsEntityStatus",
+    "GenericTriggerAnnotationsManagedType",
+    "GenericTriggerAnnotationsProvisioningStatus",
+    "GenericTriggerAnnotationsScheduleActionType",
+    "GenericTriggerAnnotationsScheduleMethod",
+    "GenericTriggerAnnotationsTriggerType",
+    "GenerictriggersUnversionedEntityKind",
+    "IndependentPipelineAnnotationsEntityStatus",
+    "IndependentPipelineAnnotationsLastRunStatusCode",
+    "IndependentpipelinesUnversionedEntityKind",
+    "IndexColumnDataType",
+    "IndexColumnDtoType",
+    "IndexEntitiesRequestOrderDirection",
+    "MaterializationSettingsMaterializationStoreType",
+    "ModelsVersionedEntityKind",
+    "ModuleAnnotationsAmlModuleEntityStatus",
+    "ModuleAnnotationsEntityStatus",
+    "ModuleAnnotationsModuleType",
+    "ModulesVersionedEntityKind",
+    "NotificationSettingEmailOnItem",
+    "OnlineendpointsUnversionedEntityKind",
+    "PipelineAnnotationsEntityStatus",
+    "PipelineAnnotationsLastRunStatusCode",
+    "PipelineDraftAnnotationsEntityStatus",
+    "PipelineRunAnnotationsEntityStatus",
+    "PipelinedraftsUnversionedEntityKind",
+    "PipelinerunsUnversionedEntityKind",
+    "PipelinesVersionedEntityKind",
+    "RecurrenceFrequency",
+    "RecurrenceScheduleWeekDaysItem",
+    "RecurrenceTriggerFrequency",
+    "RunsUnversionedEntityKind",
+    "StructuredInterfaceParameterType",
+]
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_index_service_apis_enums.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_index_service_apis_enums.py
new file mode 100644
index 00000000..797089bb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_index_service_apis_enums.py
@@ -0,0 +1,344 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from enum import Enum
+from azure.core import CaseInsensitiveEnumMeta
+
+
+class AssetContainerTypeFeedRename(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    WORKSPACE = "Workspace"
+    FEED = "Feed"
+    REGISTRY = "Registry"
+
+
+class BatchendpointsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class DatasetsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class DataStoreAnnotationsDataStoreType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    AZURE_BLOB = "AzureBlob"
+    AZURE_FILE = "AzureFile"
+    GLUSTER_FS = "GlusterFs"
+    AZURE_DATA_LAKE = "AzureDataLake"
+    AZURE_MY_SQL = "AzureMySql"
+    CUSTOM = "Custom"
+    HDFS = "Hdfs"
+    AZURE_SQL_DATABASE = "AzureSqlDatabase"
+    AZURE_POSTGRE_SQL = "AzurePostgreSql"
+    DBFS = "DBFS"
+    AZURE_DATA_LAKE_GEN2 = "AzureDataLakeGen2"
+
+
+class DatastoresUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class EntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class EnvironmentsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class ExperimentStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    NOT_STARTED = "NotStarted"
+    RUNNING = "Running"
+    FAILED = "Failed"
+    FINISHED = "Finished"
+    CANCELED = "Canceled"
+    FAILING = "Failing"
+
+
+class FeatureDataType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    STRING = "String"
+    INTEGER = "Integer"
+    LONG = "Long"
+    FLOAT = "Float"
+    DOUBLE = "Double"
+    BINARY = "Binary"
+    DATETIME = "Datetime"
+    BOOLEAN = "Boolean"
+
+
+class FeatureentitiesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class FeaturesetsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class FeatureSourceDtoType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    MLTABLE = "mltable"
+    CSV = "csv"
+    PARQUET = "parquet"
+
+
+class FeaturestoreentitiesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class GenericTriggerAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class GenericTriggerAnnotationsManagedType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    CUSTOMER = "Customer"
+    SYSTEM = "System"
+
+
+class GenericTriggerAnnotationsProvisioningStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    COMPLETED = "Completed"
+    PROVISIONING = "Provisioning"
+    FAILED = "Failed"
+
+
+class GenericTriggerAnnotationsScheduleActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    CREATE_JOB = "CreateJob"
+    INVOKE_ENDPOINT = "InvokeEndpoint"
+    IMPORT_DATA = "ImportData"
+    MODEL_MONITOR = "ModelMonitor"
+
+
+class GenericTriggerAnnotationsScheduleMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    CRON = "Cron"
+    RECURRENCE = "Recurrence"
+
+
+class GenericTriggerAnnotationsTriggerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    SCHEDULE = "Schedule"
+    ONCE = "Once"
+
+
+class GenerictriggersUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class IndependentPipelineAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class IndependentPipelineAnnotationsLastRunStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    NOT_STARTED = "NotStarted"
+    RUNNING = "Running"
+    FAILED = "Failed"
+    FINISHED = "Finished"
+    CANCELED = "Canceled"
+    FAILING = "Failing"
+    QUEUED = "Queued"
+    CANCEL_REQUESTED = "CancelRequested"
+
+
+class IndependentpipelinesUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class IndexColumnDataType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    STRING = "String"
+    INTEGER = "Integer"
+    LONG = "Long"
+    FLOAT = "Float"
+    DOUBLE = "Double"
+    BINARY = "Binary"
+    DATETIME = "Datetime"
+    BOOLEAN = "Boolean"
+
+
+class IndexColumnDtoType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    STRING = "string"
+    INTEGER = "integer"
+    LONG = "long"
+    FLOAT = "float"
+    DOUBLE = "double"
+    BINARY = "binary"
+    DATETIME = "datetime"
+    BOOLEAN = "boolean"
+
+
+class IndexEntitiesRequestOrderDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ASC = "Asc"
+    DESC = "Desc"
+
+
+class MaterializationSettingsMaterializationStoreType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    NONE = "None"
+    ONLINE = "Online"
+    OFFLINE = "Offline"
+    ONLINE_AND_OFFLINE = "OnlineAndOffline"
+
+
+class ModelsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class ModuleAnnotationsAmlModuleEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class ModuleAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class ModuleAnnotationsModuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    USER = "User"
+    BUILTIN = "Builtin"
+
+
+class ModulesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class NotificationSettingEmailOnItem(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    JOB_COMPLETED = "JobCompleted"
+    JOB_FAILED = "JobFailed"
+    JOB_CANCELLED = "JobCancelled"
+
+
+class OnlineendpointsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class PipelineAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class PipelineAnnotationsLastRunStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    NOT_STARTED = "NotStarted"
+    RUNNING = "Running"
+    FAILED = "Failed"
+    FINISHED = "Finished"
+    CANCELED = "Canceled"
+    FAILING = "Failing"
+    QUEUED = "Queued"
+    CANCEL_REQUESTED = "CancelRequested"
+
+
+class PipelineDraftAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class PipelinedraftsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class PipelineRunAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    ACTIVE = "Active"
+    DEPRECATED = "Deprecated"
+    DISABLED = "Disabled"
+
+
+class PipelinerunsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class PipelinesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class RecurrenceFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    MONTH = "Month"
+    WEEK = "Week"
+    DAY = "Day"
+    HOUR = "Hour"
+    MINUTE = "Minute"
+
+
+class RecurrenceScheduleWeekDaysItem(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    MONDAY = "Monday"
+    TUESDAY = "Tuesday"
+    WEDNESDAY = "Wednesday"
+    THURSDAY = "Thursday"
+    FRIDAY = "Friday"
+    SATURDAY = "Saturday"
+    SUNDAY = "Sunday"
+
+
+class RecurrenceTriggerFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    MONTH = "Month"
+    WEEK = "Week"
+    DAY = "Day"
+    HOUR = "Hour"
+    MINUTE = "Minute"
+
+
+class RunsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INVALID = "Invalid"
+    LINEAGE_ROOT = "LineageRoot"
+    VERSIONED = "Versioned"
+    UNVERSIONED = "Unversioned"
+
+
+class StructuredInterfaceParameterType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    INT = "Int"
+    DOUBLE = "Double"
+    BOOL = "Bool"
+    STRING = "String"
+    UNDEFINED = "Undefined"
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models.py
new file mode 100644
index 00000000..2ff74b26
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models.py
@@ -0,0 +1,9226 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+import msrest.serialization
+
+
+class BatchEndpointAnnotations(msrest.serialization.Model):
+    """BatchEndpointAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar scoring_uri: Required.
+    :vartype scoring_uri: str
+    :ivar location: Required.
+    :vartype location: str
+    :ivar last_modified_time: Required.
+    :vartype last_modified_time: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "scoring_uri": {"required": True},
+        "location": {"required": True},
+        "last_modified_time": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "scoring_uri": {"key": "scoringUri", "type": "str"},
+        "location": {"key": "location", "type": "str"},
+        "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword scoring_uri: Required.
+        :paramtype scoring_uri: str
+        :keyword location: Required.
+        :paramtype location: str
+        :keyword last_modified_time: Required.
+        :paramtype last_modified_time: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(BatchEndpointAnnotations, self).__init__(**kwargs)
+        self.scoring_uri = kwargs["scoring_uri"]
+        self.location = kwargs["location"]
+        self.last_modified_time = kwargs["last_modified_time"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class BatchEndpointProperties(msrest.serialization.Model):
+    """BatchEndpointProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "properties": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "properties": {"key": "properties", "type": "{str}"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(BatchEndpointProperties, self).__init__(**kwargs)
+        self.properties = kwargs["properties"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class BatchendpointsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """BatchendpointsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[BatchendpointsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(BatchendpointsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class BatchendpointsUnversionedEntity(msrest.serialization.Model):
+    """BatchendpointsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.BatchEndpointAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.BatchEndpointProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "BatchEndpointAnnotations"},
+        "properties": {"key": "properties", "type": "BatchEndpointProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.BatchEndpointAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.BatchEndpointProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(BatchendpointsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class Compute(msrest.serialization.Model):
+    """Compute.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar target: Required.
+    :vartype target: str
+    :ivar target_type: Required.
+    :vartype target_type: str
+    :ivar vm_size: Required.
+    :vartype vm_size: str
+    :ivar instance_type: Required.
+    :vartype instance_type: str
+    :ivar instance_count: Required.
+    :vartype instance_count: int
+    :ivar gpu_count: Required.
+    :vartype gpu_count: int
+    :ivar priority: Required.
+    :vartype priority: str
+    :ivar region: Required.
+    :vartype region: str
+    :ivar arm_id: Required.
+    :vartype arm_id: str
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    """
+
+    _validation = {
+        "target": {"required": True},
+        "target_type": {"required": True},
+        "vm_size": {"required": True},
+        "instance_type": {"required": True},
+        "instance_count": {"required": True},
+        "gpu_count": {"required": True},
+        "priority": {"required": True},
+        "region": {"required": True},
+        "arm_id": {"required": True},
+        "properties": {"required": True},
+    }
+
+    _attribute_map = {
+        "target": {"key": "target", "type": "str"},
+        "target_type": {"key": "targetType", "type": "str"},
+        "vm_size": {"key": "vmSize", "type": "str"},
+        "instance_type": {"key": "instanceType", "type": "str"},
+        "instance_count": {"key": "instanceCount", "type": "int"},
+        "gpu_count": {"key": "gpuCount", "type": "int"},
+        "priority": {"key": "priority", "type": "str"},
+        "region": {"key": "region", "type": "str"},
+        "arm_id": {"key": "armId", "type": "str"},
+        "properties": {"key": "properties", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword target: Required.
+        :paramtype target: str
+        :keyword target_type: Required.
+        :paramtype target_type: str
+        :keyword vm_size: Required.
+        :paramtype vm_size: str
+        :keyword instance_type: Required.
+        :paramtype instance_type: str
+        :keyword instance_count: Required.
+        :paramtype instance_count: int
+        :keyword gpu_count: Required.
+        :paramtype gpu_count: int
+        :keyword priority: Required.
+        :paramtype priority: str
+        :keyword region: Required.
+        :paramtype region: str
+        :keyword arm_id: Required.
+        :paramtype arm_id: str
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        """
+        super(Compute, self).__init__(**kwargs)
+        self.target = kwargs["target"]
+        self.target_type = kwargs["target_type"]
+        self.vm_size = kwargs["vm_size"]
+        self.instance_type = kwargs["instance_type"]
+        self.instance_count = kwargs["instance_count"]
+        self.gpu_count = kwargs["gpu_count"]
+        self.priority = kwargs["priority"]
+        self.region = kwargs["region"]
+        self.arm_id = kwargs["arm_id"]
+        self.properties = kwargs["properties"]
+
+
+class ComputeRequest(msrest.serialization.Model):
+    """ComputeRequest.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar node_count: Required.
+    :vartype node_count: int
+    :ivar gpu_count: Required.
+    :vartype gpu_count: int
+    """
+
+    _validation = {
+        "node_count": {"required": True},
+        "gpu_count": {"required": True},
+    }
+
+    _attribute_map = {
+        "node_count": {"key": "nodeCount", "type": "int"},
+        "gpu_count": {"key": "gpuCount", "type": "int"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword node_count: Required.
+        :paramtype node_count: int
+        :keyword gpu_count: Required.
+        :paramtype gpu_count: int
+        """
+        super(ComputeRequest, self).__init__(**kwargs)
+        self.node_count = kwargs["node_count"]
+        self.gpu_count = kwargs["gpu_count"]
+
+
+class ContainerResourceRequirements(msrest.serialization.Model):
+    """ContainerResourceRequirements.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar cpu: Required.
+    :vartype cpu: float
+    :ivar cpu_limit: Required.
+    :vartype cpu_limit: float
+    :ivar memory_in_gb: Required.
+    :vartype memory_in_gb: float
+    :ivar memory_in_gb_limit: Required.
+    :vartype memory_in_gb_limit: float
+    :ivar gpu_enabled: Required.
+    :vartype gpu_enabled: bool
+    :ivar gpu: Required.
+    :vartype gpu: int
+    :ivar fpga: Required.
+    :vartype fpga: int
+    """
+
+    _validation = {
+        "cpu": {"required": True},
+        "cpu_limit": {"required": True},
+        "memory_in_gb": {"required": True},
+        "memory_in_gb_limit": {"required": True},
+        "gpu_enabled": {"required": True},
+        "gpu": {"required": True},
+        "fpga": {"required": True},
+    }
+
+    _attribute_map = {
+        "cpu": {"key": "cpu", "type": "float"},
+        "cpu_limit": {"key": "cpuLimit", "type": "float"},
+        "memory_in_gb": {"key": "memoryInGB", "type": "float"},
+        "memory_in_gb_limit": {"key": "memoryInGBLimit", "type": "float"},
+        "gpu_enabled": {"key": "gpuEnabled", "type": "bool"},
+        "gpu": {"key": "gpu", "type": "int"},
+        "fpga": {"key": "fpga", "type": "int"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword cpu: Required.
+        :paramtype cpu: float
+        :keyword cpu_limit: Required.
+        :paramtype cpu_limit: float
+        :keyword memory_in_gb: Required.
+        :paramtype memory_in_gb: float
+        :keyword memory_in_gb_limit: Required.
+        :paramtype memory_in_gb_limit: float
+        :keyword gpu_enabled: Required.
+        :paramtype gpu_enabled: bool
+        :keyword gpu: Required.
+        :paramtype gpu: int
+        :keyword fpga: Required.
+        :paramtype fpga: int
+        """
+        super(ContainerResourceRequirements, self).__init__(**kwargs)
+        self.cpu = kwargs["cpu"]
+        self.cpu_limit = kwargs["cpu_limit"]
+        self.memory_in_gb = kwargs["memory_in_gb"]
+        self.memory_in_gb_limit = kwargs["memory_in_gb_limit"]
+        self.gpu_enabled = kwargs["gpu_enabled"]
+        self.gpu = kwargs["gpu"]
+        self.fpga = kwargs["fpga"]
+
+
+class ControlOutput(msrest.serialization.Model):
+    """ControlOutput.
+
+    :ivar name:
+    :vartype name: str
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name:
+        :paramtype name: str
+        """
+        super(ControlOutput, self).__init__(**kwargs)
+        self.name = kwargs.get("name", None)
+
+
+class CreatedBy(msrest.serialization.Model):
+    """CreatedBy.
+
+    :ivar user_object_id:
+    :vartype user_object_id: str
+    :ivar user_tenant_id:
+    :vartype user_tenant_id: str
+    :ivar user_name:
+    :vartype user_name: str
+    """
+
+    _attribute_map = {
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_name": {"key": "userName", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword user_object_id:
+        :paramtype user_object_id: str
+        :keyword user_tenant_id:
+        :paramtype user_tenant_id: str
+        :keyword user_name:
+        :paramtype user_name: str
+        """
+        super(CreatedBy, self).__init__(**kwargs)
+        self.user_object_id = kwargs.get("user_object_id", None)
+        self.user_tenant_id = kwargs.get("user_tenant_id", None)
+        self.user_name = kwargs.get("user_name", None)
+
+
+class CreatedBy1(msrest.serialization.Model):
+    """CreatedBy1.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar user_object_id: Required.
+    :vartype user_object_id: str
+    :ivar user_tenant_id: Required.
+    :vartype user_tenant_id: str
+    :ivar user_name: Required.
+    :vartype user_name: str
+    """
+
+    _validation = {
+        "user_object_id": {"required": True},
+        "user_tenant_id": {"required": True},
+        "user_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_name": {"key": "userName", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword user_object_id: Required.
+        :paramtype user_object_id: str
+        :keyword user_tenant_id: Required.
+        :paramtype user_tenant_id: str
+        :keyword user_name: Required.
+        :paramtype user_name: str
+        """
+        super(CreatedBy1, self).__init__(**kwargs)
+        self.user_object_id = kwargs["user_object_id"]
+        self.user_tenant_id = kwargs["user_tenant_id"]
+        self.user_name = kwargs["user_name"]
+
+
+class CreationContext(msrest.serialization.Model):
+    """CreationContext.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar created_time:
+    :vartype created_time: ~datetime.datetime
+    :ivar created_by:
+    :vartype created_by: ~index_service_apis.models.CreatedBy
+    :ivar creation_source:
+    :vartype creation_source: str
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "created_time": {"key": "createdTime", "type": "iso-8601"},
+        "created_by": {"key": "createdBy", "type": "CreatedBy"},
+        "creation_source": {"key": "creationSource", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword created_time:
+        :paramtype created_time: ~datetime.datetime
+        :keyword created_by:
+        :paramtype created_by: ~index_service_apis.models.CreatedBy
+        :keyword creation_source:
+        :paramtype creation_source: str
+        """
+        super(CreationContext, self).__init__(**kwargs)
+        self.additional_properties = kwargs.get("additional_properties", None)
+        self.created_time = kwargs.get("created_time", None)
+        self.created_by = kwargs.get("created_by", None)
+        self.creation_source = kwargs.get("creation_source", None)
+
+
+class CronTrigger(msrest.serialization.Model):
+    """CronTrigger.
+
+    :ivar expression:
+    :vartype expression: str
+    """
+
+    _attribute_map = {
+        "expression": {"key": "expression", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword expression:
+        :paramtype expression: str
+        """
+        super(CronTrigger, self).__init__(**kwargs)
+        self.expression = kwargs.get("expression", None)
+
+
+class CrossRegionIndexEntitiesRequest(msrest.serialization.Model):
+    """CrossRegionIndexEntitiesRequest.
+
+    :ivar resource_ids:
+    :vartype resource_ids: list[~index_service_apis.models.ResourceInformation]
+    :ivar index_entities_request:
+    :vartype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest
+    """
+
+    _attribute_map = {
+        "resource_ids": {"key": "resourceIds", "type": "[ResourceInformation]"},
+        "index_entities_request": {"key": "indexEntitiesRequest", "type": "IndexEntitiesRequest"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword resource_ids:
+        :paramtype resource_ids: list[~index_service_apis.models.ResourceInformation]
+        :keyword index_entities_request:
+        :paramtype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest
+        """
+        super(CrossRegionIndexEntitiesRequest, self).__init__(**kwargs)
+        self.resource_ids = kwargs.get("resource_ids", None)
+        self.index_entities_request = kwargs.get("index_entities_request", None)
+
+
+class CrossRegionIndexEntitiesResponse(msrest.serialization.Model):
+    """CrossRegionIndexEntitiesResponse.
+
+    :ivar index_entities_response:
+    :vartype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse
+    :ivar regional_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar shard_errors: Dictionary of
+     <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>.
+    :vartype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]]
+    :ivar number_of_resources_not_included_in_search:
+    :vartype number_of_resources_not_included_in_search: int
+    """
+
+    _attribute_map = {
+        "index_entities_response": {"key": "indexEntitiesResponse", "type": "IndexEntitiesResponse"},
+        "regional_errors": {"key": "regionalErrors", "type": "{ErrorResponse}"},
+        "shard_errors": {"key": "shardErrors", "type": "{{ErrorResponse}}"},
+        "number_of_resources_not_included_in_search": {"key": "numberOfResourcesNotIncludedInSearch", "type": "int"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword index_entities_response:
+        :paramtype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse
+        :keyword regional_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword shard_errors: Dictionary of
+         <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>.
+        :paramtype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]]
+        :keyword number_of_resources_not_included_in_search:
+        :paramtype number_of_resources_not_included_in_search: int
+        """
+        super(CrossRegionIndexEntitiesResponse, self).__init__(**kwargs)
+        self.index_entities_response = kwargs.get("index_entities_response", None)
+        self.regional_errors = kwargs.get("regional_errors", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.number_of_resources_not_included_in_search = kwargs.get("number_of_resources_not_included_in_search", None)
+
+
+class CudaAttribute(msrest.serialization.Model):
+    """CudaAttribute.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar cuda_version: Required.
+    :vartype cuda_version: str
+    :ivar cu_dnn_version: Required.
+    :vartype cu_dnn_version: str
+    :ivar nccl_version: Required.
+    :vartype nccl_version: str
+    """
+
+    _validation = {
+        "cuda_version": {"required": True},
+        "cu_dnn_version": {"required": True},
+        "nccl_version": {"required": True},
+    }
+
+    _attribute_map = {
+        "cuda_version": {"key": "cudaVersion", "type": "str"},
+        "cu_dnn_version": {"key": "cuDnnVersion", "type": "str"},
+        "nccl_version": {"key": "ncclVersion", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword cuda_version: Required.
+        :paramtype cuda_version: str
+        :keyword cu_dnn_version: Required.
+        :paramtype cu_dnn_version: str
+        :keyword nccl_version: Required.
+        :paramtype nccl_version: str
+        """
+        super(CudaAttribute, self).__init__(**kwargs)
+        self.cuda_version = kwargs["cuda_version"]
+        self.cu_dnn_version = kwargs["cu_dnn_version"]
+        self.nccl_version = kwargs["nccl_version"]
+
+
+class DatasetAnnotations(msrest.serialization.Model):
+    """DatasetAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar modified_time: Required.
+    :vartype modified_time: ~datetime.datetime
+    :ivar modified_by: Required.
+    :vartype modified_by: ~index_service_apis.models.UserDto
+    :ivar next_version_id: Required.
+    :vartype next_version_id: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar labels: Required. Dictionary of :code:`<string>`.
+    :vartype labels: dict[str, str]
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "modified_time": {"required": True},
+        "modified_by": {"required": True},
+        "next_version_id": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "labels": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "modified_time": {"key": "modifiedTime", "type": "iso-8601"},
+        "modified_by": {"key": "modifiedBy", "type": "UserDto"},
+        "next_version_id": {"key": "nextVersionId", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "labels": {"key": "labels", "type": "{str}"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword modified_time: Required.
+        :paramtype modified_time: ~datetime.datetime
+        :keyword modified_by: Required.
+        :paramtype modified_by: ~index_service_apis.models.UserDto
+        :keyword next_version_id: Required.
+        :paramtype next_version_id: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword labels: Required. Dictionary of :code:`<string>`.
+        :paramtype labels: dict[str, str]
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(DatasetAnnotations, self).__init__(**kwargs)
+        self.modified_time = kwargs["modified_time"]
+        self.modified_by = kwargs["modified_by"]
+        self.next_version_id = kwargs["next_version_id"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.labels = kwargs["labels"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class DatasetProperties(msrest.serialization.Model):
+    """DatasetProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar subtype: Required.
+    :vartype subtype: str
+    :ivar is_registered: Required.
+    :vartype is_registered: bool
+    :ivar data_type: Required.
+    :vartype data_type: str
+    :ivar is_v2: Required.
+    :vartype is_v2: bool
+    :ivar name_lower_case: Required.
+    :vartype name_lower_case: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "subtype": {"required": True},
+        "is_registered": {"required": True},
+        "data_type": {"required": True},
+        "is_v2": {"required": True},
+        "name_lower_case": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "subtype": {"key": "subtype", "type": "str"},
+        "is_registered": {"key": "isRegistered", "type": "bool"},
+        "data_type": {"key": "dataType", "type": "str"},
+        "is_v2": {"key": "isV2", "type": "bool"},
+        "name_lower_case": {"key": "nameLowerCase", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword subtype: Required.
+        :paramtype subtype: str
+        :keyword is_registered: Required.
+        :paramtype is_registered: bool
+        :keyword data_type: Required.
+        :paramtype data_type: str
+        :keyword is_v2: Required.
+        :paramtype is_v2: bool
+        :keyword name_lower_case: Required.
+        :paramtype name_lower_case: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(DatasetProperties, self).__init__(**kwargs)
+        self.subtype = kwargs["subtype"]
+        self.is_registered = kwargs["is_registered"]
+        self.data_type = kwargs["data_type"]
+        self.is_v2 = kwargs["is_v2"]
+        self.name_lower_case = kwargs["name_lower_case"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class DatasetReference(msrest.serialization.Model):
+    """DatasetReference.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar id: Required.
+    :vartype id: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "id": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "id": {"key": "id", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword id: Required.
+        :paramtype id: str
+        """
+        super(DatasetReference, self).__init__(**kwargs)
+        self.name = kwargs["name"]
+        self.id = kwargs["id"]
+
+
+class DatasetsVersionedEntitiesResponse(msrest.serialization.Model):
+    """DatasetsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.DatasetsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[DatasetsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.DatasetsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(DatasetsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class DatasetsVersionedEntity(msrest.serialization.Model):
+    """DatasetsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.DatasetAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.DatasetProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "DatasetAnnotations"},
+        "properties": {"key": "properties", "type": "DatasetProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.DatasetAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.DatasetProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(DatasetsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class DataStoreAnnotations(msrest.serialization.Model):
+    """DataStoreAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar data_store_type: Required. Possible values include: "AzureBlob", "AzureFile",
+     "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase",
+     "AzurePostgreSql", "DBFS", "AzureDataLakeGen2".
+    :vartype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType
+    :ivar data_store_type_name: Required.
+    :vartype data_store_type_name: str
+    :ivar storage_name: Required.
+    :vartype storage_name: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "data_store_type": {"required": True},
+        "data_store_type_name": {"required": True},
+        "storage_name": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "data_store_type": {"key": "dataStoreType", "type": "str"},
+        "data_store_type_name": {"key": "dataStoreTypeName", "type": "str"},
+        "storage_name": {"key": "storageName", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword data_store_type: Required. Possible values include: "AzureBlob", "AzureFile",
+         "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase",
+         "AzurePostgreSql", "DBFS", "AzureDataLakeGen2".
+        :paramtype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType
+        :keyword data_store_type_name: Required.
+        :paramtype data_store_type_name: str
+        :keyword storage_name: Required.
+        :paramtype storage_name: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(DataStoreAnnotations, self).__init__(**kwargs)
+        self.data_store_type = kwargs["data_store_type"]
+        self.data_store_type_name = kwargs["data_store_type_name"]
+        self.storage_name = kwargs["storage_name"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class DataStoreProperties(msrest.serialization.Model):
+    """DataStoreProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(DataStoreProperties, self).__init__(**kwargs)
+        self.creation_context = kwargs["creation_context"]
+
+
+class DatastoresUnversionedEntitiesResponse(msrest.serialization.Model):
+    """DatastoresUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.DatastoresUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[DatastoresUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.DatastoresUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(DatastoresUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class DatastoresUnversionedEntity(msrest.serialization.Model):
+    """DatastoresUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.DataStoreAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.DataStoreProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "DataStoreAnnotations"},
+        "properties": {"key": "properties", "type": "DataStoreProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.DataStoreAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.DataStoreProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(DatastoresUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class DebugInfoResponse(msrest.serialization.Model):
+    """DebugInfoResponse.
+
+    :ivar type:
+    :vartype type: str
+    :ivar message:
+    :vartype message: str
+    :ivar stack_trace:
+    :vartype stack_trace: str
+    :ivar inner_exception:
+    :vartype inner_exception: ~index_service_apis.models.DebugInfoResponse
+    :ivar data: Dictionary of :code:`<any>`.
+    :vartype data: dict[str, any]
+    :ivar error_response:
+    :vartype error_response: ~index_service_apis.models.ErrorResponse
+    """
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "message": {"key": "message", "type": "str"},
+        "stack_trace": {"key": "stackTrace", "type": "str"},
+        "inner_exception": {"key": "innerException", "type": "DebugInfoResponse"},
+        "data": {"key": "data", "type": "{object}"},
+        "error_response": {"key": "errorResponse", "type": "ErrorResponse"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword type:
+        :paramtype type: str
+        :keyword message:
+        :paramtype message: str
+        :keyword stack_trace:
+        :paramtype stack_trace: str
+        :keyword inner_exception:
+        :paramtype inner_exception: ~index_service_apis.models.DebugInfoResponse
+        :keyword data: Dictionary of :code:`<any>`.
+        :paramtype data: dict[str, any]
+        :keyword error_response:
+        :paramtype error_response: ~index_service_apis.models.ErrorResponse
+        """
+        super(DebugInfoResponse, self).__init__(**kwargs)
+        self.type = kwargs.get("type", None)
+        self.message = kwargs.get("message", None)
+        self.stack_trace = kwargs.get("stack_trace", None)
+        self.inner_exception = kwargs.get("inner_exception", None)
+        self.data = kwargs.get("data", None)
+        self.error_response = kwargs.get("error_response", None)
+
+
+class DefinitionAnnotations(msrest.serialization.Model):
+    """DefinitionAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(DefinitionAnnotations, self).__init__(**kwargs)
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class DefinitionProperties(msrest.serialization.Model):
+    """DefinitionProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar automatically_saved: Required.
+    :vartype automatically_saved: bool
+    :ivar definition_hash: Required.
+    :vartype definition_hash: str
+    :ivar environment_attributes: Required.
+    :vartype environment_attributes: ~index_service_apis.models.EnvironmentAttributes
+    :ivar stage: Required.
+    :vartype stage: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "automatically_saved": {"required": True},
+        "definition_hash": {"required": True},
+        "environment_attributes": {"required": True},
+        "stage": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "automatically_saved": {"key": "automaticallySaved", "type": "bool"},
+        "definition_hash": {"key": "definitionHash", "type": "str"},
+        "environment_attributes": {"key": "environmentAttributes", "type": "EnvironmentAttributes"},
+        "stage": {"key": "stage", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword automatically_saved: Required.
+        :paramtype automatically_saved: bool
+        :keyword definition_hash: Required.
+        :paramtype definition_hash: str
+        :keyword environment_attributes: Required.
+        :paramtype environment_attributes: ~index_service_apis.models.EnvironmentAttributes
+        :keyword stage: Required.
+        :paramtype stage: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(DefinitionProperties, self).__init__(**kwargs)
+        self.automatically_saved = kwargs["automatically_saved"]
+        self.definition_hash = kwargs["definition_hash"]
+        self.environment_attributes = kwargs["environment_attributes"]
+        self.stage = kwargs["stage"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class EndpointComputeTarget(msrest.serialization.Model):
+    """EndpointComputeTarget.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar namespace: Required.
+    :vartype namespace: str
+    :ivar compute_target_name: Required.
+    :vartype compute_target_name: str
+    """
+
+    _validation = {
+        "namespace": {"required": True},
+        "compute_target_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "namespace": {"key": "namespace", "type": "str"},
+        "compute_target_name": {"key": "computeTargetName", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword namespace: Required.
+        :paramtype namespace: str
+        :keyword compute_target_name: Required.
+        :paramtype compute_target_name: str
+        """
+        super(EndpointComputeTarget, self).__init__(**kwargs)
+        self.namespace = kwargs["namespace"]
+        self.compute_target_name = kwargs["compute_target_name"]
+
+
+class EnvironmentAttributes(msrest.serialization.Model):
+    """EnvironmentAttributes.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar machine_learning_framework: Required.
+    :vartype machine_learning_framework: ~index_service_apis.models.VersionedAttribute
+    :ivar mpi: Required.
+    :vartype mpi: ~index_service_apis.models.VersionedAttribute
+    :ivar runtime: Required.
+    :vartype runtime: ~index_service_apis.models.VersionedAttribute
+    :ivar cuda: Required.
+    :vartype cuda: ~index_service_apis.models.CudaAttribute
+    :ivar purpose: Required.
+    :vartype purpose: ~index_service_apis.models.Purpose
+    :ivar os: Required.
+    :vartype os: ~index_service_apis.models.VersionedAttribute
+    """
+
+    _validation = {
+        "machine_learning_framework": {"required": True},
+        "mpi": {"required": True},
+        "runtime": {"required": True},
+        "cuda": {"required": True},
+        "purpose": {"required": True},
+        "os": {"required": True},
+    }
+
+    _attribute_map = {
+        "machine_learning_framework": {"key": "machineLearningFramework", "type": "VersionedAttribute"},
+        "mpi": {"key": "mpi", "type": "VersionedAttribute"},
+        "runtime": {"key": "runtime", "type": "VersionedAttribute"},
+        "cuda": {"key": "cuda", "type": "CudaAttribute"},
+        "purpose": {"key": "purpose", "type": "Purpose"},
+        "os": {"key": "os", "type": "VersionedAttribute"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword machine_learning_framework: Required.
+        :paramtype machine_learning_framework: ~index_service_apis.models.VersionedAttribute
+        :keyword mpi: Required.
+        :paramtype mpi: ~index_service_apis.models.VersionedAttribute
+        :keyword runtime: Required.
+        :paramtype runtime: ~index_service_apis.models.VersionedAttribute
+        :keyword cuda: Required.
+        :paramtype cuda: ~index_service_apis.models.CudaAttribute
+        :keyword purpose: Required.
+        :paramtype purpose: ~index_service_apis.models.Purpose
+        :keyword os: Required.
+        :paramtype os: ~index_service_apis.models.VersionedAttribute
+        """
+        super(EnvironmentAttributes, self).__init__(**kwargs)
+        self.machine_learning_framework = kwargs["machine_learning_framework"]
+        self.mpi = kwargs["mpi"]
+        self.runtime = kwargs["runtime"]
+        self.cuda = kwargs["cuda"]
+        self.purpose = kwargs["purpose"]
+        self.os = kwargs["os"]
+
+
+class EnvironmentsVersionedEntitiesResponse(msrest.serialization.Model):
+    """EnvironmentsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.EnvironmentsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[EnvironmentsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.EnvironmentsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(EnvironmentsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class EnvironmentsVersionedEntity(msrest.serialization.Model):
+    """EnvironmentsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.DefinitionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.DefinitionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "DefinitionAnnotations"},
+        "properties": {"key": "properties", "type": "DefinitionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.DefinitionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.DefinitionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(EnvironmentsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class ErrorAdditionalInfo(msrest.serialization.Model):
+    """ErrorAdditionalInfo.
+
+    :ivar type:
+    :vartype type: str
+    :ivar info: Anything.
+    :vartype info: any
+    """
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "info": {"key": "info", "type": "object"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword type:
+        :paramtype type: str
+        :keyword info: Anything.
+        :paramtype info: any
+        """
+        super(ErrorAdditionalInfo, self).__init__(**kwargs)
+        self.type = kwargs.get("type", None)
+        self.info = kwargs.get("info", None)
+
+
+class ErrorResponse(msrest.serialization.Model):
+    """ErrorResponse.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar error:
+    :vartype error: ~index_service_apis.models.RootError
+    :ivar correlation: Dictionary of :code:`<string>`.
+    :vartype correlation: dict[str, str]
+    :ivar environment:
+    :vartype environment: str
+    :ivar location:
+    :vartype location: str
+    :ivar time:
+    :vartype time: ~datetime.datetime
+    :ivar component_name:
+    :vartype component_name: str
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "error": {"key": "error", "type": "RootError"},
+        "correlation": {"key": "correlation", "type": "{str}"},
+        "environment": {"key": "environment", "type": "str"},
+        "location": {"key": "location", "type": "str"},
+        "time": {"key": "time", "type": "iso-8601"},
+        "component_name": {"key": "componentName", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword error:
+        :paramtype error: ~index_service_apis.models.RootError
+        :keyword correlation: Dictionary of :code:`<string>`.
+        :paramtype correlation: dict[str, str]
+        :keyword environment:
+        :paramtype environment: str
+        :keyword location:
+        :paramtype location: str
+        :keyword time:
+        :paramtype time: ~datetime.datetime
+        :keyword component_name:
+        :paramtype component_name: str
+        """
+        super(ErrorResponse, self).__init__(**kwargs)
+        self.additional_properties = kwargs.get("additional_properties", None)
+        self.error = kwargs.get("error", None)
+        self.correlation = kwargs.get("correlation", None)
+        self.environment = kwargs.get("environment", None)
+        self.location = kwargs.get("location", None)
+        self.time = kwargs.get("time", None)
+        self.component_name = kwargs.get("component_name", None)
+
+
+class ExperimentStatus(msrest.serialization.Model):
+    """ExperimentStatus.
+
+    :ivar status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished",
+     "Canceled", "Failing".
+    :vartype status_code: str or ~index_service_apis.models.ExperimentStatusCode
+    :ivar status_detail:
+    :vartype status_detail: str
+    :ivar creation_time:
+    :vartype creation_time: ~datetime.datetime
+    :ivar end_time:
+    :vartype end_time: ~datetime.datetime
+    :ivar run_history_error_code:
+    :vartype run_history_error_code: str
+    """
+
+    _attribute_map = {
+        "status_code": {"key": "statusCode", "type": "str"},
+        "status_detail": {"key": "statusDetail", "type": "str"},
+        "creation_time": {"key": "creationTime", "type": "iso-8601"},
+        "end_time": {"key": "endTime", "type": "iso-8601"},
+        "run_history_error_code": {"key": "runHistoryErrorCode", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished",
+         "Canceled", "Failing".
+        :paramtype status_code: str or ~index_service_apis.models.ExperimentStatusCode
+        :keyword status_detail:
+        :paramtype status_detail: str
+        :keyword creation_time:
+        :paramtype creation_time: ~datetime.datetime
+        :keyword end_time:
+        :paramtype end_time: ~datetime.datetime
+        :keyword run_history_error_code:
+        :paramtype run_history_error_code: str
+        """
+        super(ExperimentStatus, self).__init__(**kwargs)
+        self.status_code = kwargs.get("status_code", None)
+        self.status_detail = kwargs.get("status_detail", None)
+        self.creation_time = kwargs.get("creation_time", None)
+        self.end_time = kwargs.get("end_time", None)
+        self.run_history_error_code = kwargs.get("run_history_error_code", None)
+
+
+class Feature(msrest.serialization.Model):
+    """Feature.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar feature_name: Required.
+    :vartype feature_name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+     "Double", "Binary", "Datetime", "Boolean".
+    :vartype data_type: str or ~index_service_apis.models.FeatureDataType
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "feature_name": {"required": True},
+        "description": {"required": True},
+        "data_type": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "feature_name": {"key": "featureName", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "data_type": {"key": "dataType", "type": "str"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword feature_name: Required.
+        :paramtype feature_name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+         "Double", "Binary", "Datetime", "Boolean".
+        :paramtype data_type: str or ~index_service_apis.models.FeatureDataType
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(Feature, self).__init__(**kwargs)
+        self.feature_name = kwargs["feature_name"]
+        self.description = kwargs["description"]
+        self.data_type = kwargs["data_type"]
+        self.tags = kwargs["tags"]
+
+
+class FeatureentitiesVersionedEntitiesResponse(msrest.serialization.Model):
+    """FeatureentitiesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[FeatureentitiesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(FeatureentitiesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class FeatureentitiesVersionedEntity(msrest.serialization.Model):
+    """FeatureentitiesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"},
+        "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(FeatureentitiesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class FeatureEntityVersionAnnotations(msrest.serialization.Model):
+    """FeatureEntityVersionAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar actual_name: Required.
+    :vartype actual_name: str
+    :ivar index_columns: Required.
+    :vartype index_columns: list[~index_service_apis.models.IndexColumnDto]
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "actual_name": {"required": True},
+        "index_columns": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "actual_name": {"key": "actualName", "type": "str"},
+        "index_columns": {"key": "indexColumns", "type": "[IndexColumnDto]"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword actual_name: Required.
+        :paramtype actual_name: str
+        :keyword index_columns: Required.
+        :paramtype index_columns: list[~index_service_apis.models.IndexColumnDto]
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(FeatureEntityVersionAnnotations, self).__init__(**kwargs)
+        self.actual_name = kwargs["actual_name"]
+        self.index_columns = kwargs["index_columns"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class FeatureEntityVersionProperties(msrest.serialization.Model):
+    """FeatureEntityVersionProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar feature_entity_name: Required.
+    :vartype feature_entity_name: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "feature_entity_name": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "feature_entity_name": {"key": "featureEntityName", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword feature_entity_name: Required.
+        :paramtype feature_entity_name: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(FeatureEntityVersionProperties, self).__init__(**kwargs)
+        self.feature_entity_name = kwargs["feature_entity_name"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class FeaturesetSpecification(msrest.serialization.Model):
+    """FeaturesetSpecification.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar path: Required.
+    :vartype path: str
+    """
+
+    _validation = {
+        "path": {"required": True},
+    }
+
+    _attribute_map = {
+        "path": {"key": "path", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword path: Required.
+        :paramtype path: str
+        """
+        super(FeaturesetSpecification, self).__init__(**kwargs)
+        self.path = kwargs["path"]
+
+
+class FeaturesetsVersionedEntitiesResponse(msrest.serialization.Model):
+    """FeaturesetsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.FeaturesetsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[FeaturesetsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.FeaturesetsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(FeaturesetsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class FeaturesetsVersionedEntity(msrest.serialization.Model):
+    """FeaturesetsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.FeatureSetVersionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "FeatureSetVersionAnnotations"},
+        "properties": {"key": "properties", "type": "FeatureSetVersionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.FeatureSetVersionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(FeaturesetsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class FeatureSetVersionAnnotations(msrest.serialization.Model):
+    """FeatureSetVersionAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar actual_name: Required.
+    :vartype actual_name: str
+    :ivar specification: Required.
+    :vartype specification: ~index_service_apis.models.FeaturesetSpecification
+    :ivar entities: Required.
+    :vartype entities: list[str]
+    :ivar features: Required.
+    :vartype features: list[~index_service_apis.models.Feature]
+    :ivar stage: Required.
+    :vartype stage: str
+    :ivar materialization_settings: Required.
+    :vartype materialization_settings: ~index_service_apis.models.MaterializationSettings
+    :ivar source: Required.
+    :vartype source: ~index_service_apis.models.FeatureSourceDto
+    :ivar feature_transformation_code: Required.
+    :vartype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto
+    :ivar temporal_join_lookback: Required.
+    :vartype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto
+    :ivar source_lookback: Required.
+    :vartype source_lookback: ~index_service_apis.models.TimeDeltaDto
+    :ivar timestamp_column: Required.
+    :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "actual_name": {"required": True},
+        "specification": {"required": True},
+        "entities": {"required": True},
+        "features": {"required": True},
+        "stage": {"required": True},
+        "materialization_settings": {"required": True},
+        "source": {"required": True},
+        "feature_transformation_code": {"required": True},
+        "temporal_join_lookback": {"required": True},
+        "source_lookback": {"required": True},
+        "timestamp_column": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "actual_name": {"key": "actualName", "type": "str"},
+        "specification": {"key": "specification", "type": "FeaturesetSpecification"},
+        "entities": {"key": "entities", "type": "[str]"},
+        "features": {"key": "features", "type": "[Feature]"},
+        "stage": {"key": "stage", "type": "str"},
+        "materialization_settings": {"key": "materializationSettings", "type": "MaterializationSettings"},
+        "source": {"key": "source", "type": "FeatureSourceDto"},
+        "feature_transformation_code": {"key": "featureTransformationCode", "type": "FeatureTransformationDto"},
+        "temporal_join_lookback": {"key": "temporalJoinLookback", "type": "TimeDeltaDto"},
+        "source_lookback": {"key": "sourceLookback", "type": "TimeDeltaDto"},
+        "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword actual_name: Required.
+        :paramtype actual_name: str
+        :keyword specification: Required.
+        :paramtype specification: ~index_service_apis.models.FeaturesetSpecification
+        :keyword entities: Required.
+        :paramtype entities: list[str]
+        :keyword features: Required.
+        :paramtype features: list[~index_service_apis.models.Feature]
+        :keyword stage: Required.
+        :paramtype stage: str
+        :keyword materialization_settings: Required.
+        :paramtype materialization_settings: ~index_service_apis.models.MaterializationSettings
+        :keyword source: Required.
+        :paramtype source: ~index_service_apis.models.FeatureSourceDto
+        :keyword feature_transformation_code: Required.
+        :paramtype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto
+        :keyword temporal_join_lookback: Required.
+        :paramtype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto
+        :keyword source_lookback: Required.
+        :paramtype source_lookback: ~index_service_apis.models.TimeDeltaDto
+        :keyword timestamp_column: Required.
+        :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(FeatureSetVersionAnnotations, self).__init__(**kwargs)
+        self.actual_name = kwargs["actual_name"]
+        self.specification = kwargs["specification"]
+        self.entities = kwargs["entities"]
+        self.features = kwargs["features"]
+        self.stage = kwargs["stage"]
+        self.materialization_settings = kwargs["materialization_settings"]
+        self.source = kwargs["source"]
+        self.feature_transformation_code = kwargs["feature_transformation_code"]
+        self.temporal_join_lookback = kwargs["temporal_join_lookback"]
+        self.source_lookback = kwargs["source_lookback"]
+        self.timestamp_column = kwargs["timestamp_column"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class FeatureSetVersionProperties(msrest.serialization.Model):
+    """FeatureSetVersionProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar feature_set_name: Required.
+    :vartype feature_set_name: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "feature_set_name": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "feature_set_name": {"key": "featureSetName", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword feature_set_name: Required.
+        :paramtype feature_set_name: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(FeatureSetVersionProperties, self).__init__(**kwargs)
+        self.feature_set_name = kwargs["feature_set_name"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class FeatureSourceDto(msrest.serialization.Model):
+    """FeatureSourceDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar type: Required. Possible values include: "mltable", "csv", "parquet".
+    :vartype type: str or ~index_service_apis.models.FeatureSourceDtoType
+    :ivar path: Required.
+    :vartype path: str
+    :ivar timestamp_column: Required.
+    :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+    :ivar source_delay: Required.
+    :vartype source_delay: ~index_service_apis.models.TimeDeltaDto
+    """
+
+    _validation = {
+        "type": {"required": True},
+        "path": {"required": True},
+        "timestamp_column": {"required": True},
+        "source_delay": {"required": True},
+    }
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "path": {"key": "path", "type": "str"},
+        "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"},
+        "source_delay": {"key": "sourceDelay", "type": "TimeDeltaDto"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword type: Required. Possible values include: "mltable", "csv", "parquet".
+        :paramtype type: str or ~index_service_apis.models.FeatureSourceDtoType
+        :keyword path: Required.
+        :paramtype path: str
+        :keyword timestamp_column: Required.
+        :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+        :keyword source_delay: Required.
+        :paramtype source_delay: ~index_service_apis.models.TimeDeltaDto
+        """
+        super(FeatureSourceDto, self).__init__(**kwargs)
+        self.type = kwargs["type"]
+        self.path = kwargs["path"]
+        self.timestamp_column = kwargs["timestamp_column"]
+        self.source_delay = kwargs["source_delay"]
+
+
+class FeaturestoreentitiesVersionedEntitiesResponse(msrest.serialization.Model):
+    """FeaturestoreentitiesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[FeaturestoreentitiesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(FeaturestoreentitiesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class FeaturestoreentitiesVersionedEntity(msrest.serialization.Model):
+    """FeaturestoreentitiesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"},
+        "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(FeaturestoreentitiesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class FeatureTransformationDto(msrest.serialization.Model):
+    """FeatureTransformationDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar path: Required.
+    :vartype path: str
+    :ivar transformer_class: Required.
+    :vartype transformer_class: str
+    """
+
+    _validation = {
+        "path": {"required": True},
+        "transformer_class": {"required": True},
+    }
+
+    _attribute_map = {
+        "path": {"key": "path", "type": "str"},
+        "transformer_class": {"key": "transformerClass", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword path: Required.
+        :paramtype path: str
+        :keyword transformer_class: Required.
+        :paramtype transformer_class: str
+        """
+        super(FeatureTransformationDto, self).__init__(**kwargs)
+        self.path = kwargs["path"]
+        self.transformer_class = kwargs["transformer_class"]
+
+
+class FreeTextSearchColumn(msrest.serialization.Model):
+    """FreeTextSearchColumn.
+
+    :ivar name:
+    :vartype name: str
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name:
+        :paramtype name: str
+        """
+        super(FreeTextSearchColumn, self).__init__(**kwargs)
+        self.name = kwargs.get("name", None)
+
+
+class GenericTriggerAnnotations(msrest.serialization.Model):
+    """GenericTriggerAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar display_name: Required.
+    :vartype display_name: str
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar provisioning_status: Required. Possible values include: "Completed", "Provisioning",
+     "Failed".
+    :vartype provisioning_status: str or
+     ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus
+    :ivar trigger_type: Required. Possible values include: "Schedule", "Once".
+    :vartype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType
+    :ivar schedule_method: Required. Possible values include: "Cron", "Recurrence".
+    :vartype schedule_method: str or
+     ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod
+    :ivar schedule_action_type: Required. Possible values include: "CreateJob", "InvokeEndpoint",
+     "ImportData", "ModelMonitor".
+    :vartype schedule_action_type: str or
+     ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType
+    :ivar recurrence: Required.
+    :vartype recurrence: ~index_service_apis.models.RecurrenceTrigger
+    :ivar cron: Required.
+    :vartype cron: ~index_service_apis.models.CronTrigger
+    :ivar start_time: Required.
+    :vartype start_time: str
+    :ivar end_time: Required.
+    :vartype end_time: str
+    :ivar time_zone: Required.
+    :vartype time_zone: str
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar definition: Required.
+    :vartype definition: str
+    :ivar feature_definition: Required.
+    :vartype feature_definition: str
+    :ivar managed_type: Required. Possible values include: "Customer", "System".
+    :vartype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType
+    :ivar scenario_name: Required.
+    :vartype scenario_name: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "display_name": {"required": True},
+        "kv_tags": {"required": True},
+        "properties": {"required": True},
+        "provisioning_status": {"required": True},
+        "trigger_type": {"required": True},
+        "schedule_method": {"required": True},
+        "schedule_action_type": {"required": True},
+        "recurrence": {"required": True},
+        "cron": {"required": True},
+        "start_time": {"required": True},
+        "end_time": {"required": True},
+        "time_zone": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "definition": {"required": True},
+        "feature_definition": {"required": True},
+        "managed_type": {"required": True},
+        "scenario_name": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "display_name": {"key": "displayName", "type": "str"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "provisioning_status": {"key": "provisioningStatus", "type": "str"},
+        "trigger_type": {"key": "triggerType", "type": "str"},
+        "schedule_method": {"key": "scheduleMethod", "type": "str"},
+        "schedule_action_type": {"key": "scheduleActionType", "type": "str"},
+        "recurrence": {"key": "recurrence", "type": "RecurrenceTrigger"},
+        "cron": {"key": "cron", "type": "CronTrigger"},
+        "start_time": {"key": "startTime", "type": "str"},
+        "end_time": {"key": "endTime", "type": "str"},
+        "time_zone": {"key": "timeZone", "type": "str"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "definition": {"key": "definition", "type": "str"},
+        "feature_definition": {"key": "featureDefinition", "type": "str"},
+        "managed_type": {"key": "managedType", "type": "str"},
+        "scenario_name": {"key": "scenarioName", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword display_name: Required.
+        :paramtype display_name: str
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword provisioning_status: Required. Possible values include: "Completed", "Provisioning",
+         "Failed".
+        :paramtype provisioning_status: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus
+        :keyword trigger_type: Required. Possible values include: "Schedule", "Once".
+        :paramtype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType
+        :keyword schedule_method: Required. Possible values include: "Cron", "Recurrence".
+        :paramtype schedule_method: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod
+        :keyword schedule_action_type: Required. Possible values include: "CreateJob",
+         "InvokeEndpoint", "ImportData", "ModelMonitor".
+        :paramtype schedule_action_type: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType
+        :keyword recurrence: Required.
+        :paramtype recurrence: ~index_service_apis.models.RecurrenceTrigger
+        :keyword cron: Required.
+        :paramtype cron: ~index_service_apis.models.CronTrigger
+        :keyword start_time: Required.
+        :paramtype start_time: str
+        :keyword end_time: Required.
+        :paramtype end_time: str
+        :keyword time_zone: Required.
+        :paramtype time_zone: str
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword definition: Required.
+        :paramtype definition: str
+        :keyword feature_definition: Required.
+        :paramtype feature_definition: str
+        :keyword managed_type: Required. Possible values include: "Customer", "System".
+        :paramtype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType
+        :keyword scenario_name: Required.
+        :paramtype scenario_name: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(GenericTriggerAnnotations, self).__init__(**kwargs)
+        self.display_name = kwargs["display_name"]
+        self.kv_tags = kwargs["kv_tags"]
+        self.properties = kwargs["properties"]
+        self.provisioning_status = kwargs["provisioning_status"]
+        self.trigger_type = kwargs["trigger_type"]
+        self.schedule_method = kwargs["schedule_method"]
+        self.schedule_action_type = kwargs["schedule_action_type"]
+        self.recurrence = kwargs["recurrence"]
+        self.cron = kwargs["cron"]
+        self.start_time = kwargs["start_time"]
+        self.end_time = kwargs["end_time"]
+        self.time_zone = kwargs["time_zone"]
+        self.entity_status = kwargs["entity_status"]
+        self.last_modified_date = kwargs["last_modified_date"]
+        self.last_updated_by = kwargs["last_updated_by"]
+        self.definition = kwargs["definition"]
+        self.feature_definition = kwargs["feature_definition"]
+        self.managed_type = kwargs["managed_type"]
+        self.scenario_name = kwargs["scenario_name"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class GenericTriggerProperties(msrest.serialization.Model):
+    """GenericTriggerProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(GenericTriggerProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class GenerictriggersUnversionedEntitiesResponse(msrest.serialization.Model):
+    """GenerictriggersUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[GenerictriggersUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(GenerictriggersUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class GenerictriggersUnversionedEntity(msrest.serialization.Model):
+    """GenerictriggersUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.GenericTriggerAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.GenericTriggerProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "GenericTriggerAnnotations"},
+        "properties": {"key": "properties", "type": "GenericTriggerProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.GenericTriggerAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.GenericTriggerProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(GenerictriggersUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class HighlightOptions(msrest.serialization.Model):
+    """HighlightOptions.
+
+    :ivar pre_tag:
+    :vartype pre_tag: str
+    :ivar post_tag:
+    :vartype post_tag: str
+    :ivar fields:
+    :vartype fields: list[str]
+    """
+
+    _attribute_map = {
+        "pre_tag": {"key": "preTag", "type": "str"},
+        "post_tag": {"key": "postTag", "type": "str"},
+        "fields": {"key": "fields", "type": "[str]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword pre_tag:
+        :paramtype pre_tag: str
+        :keyword post_tag:
+        :paramtype post_tag: str
+        :keyword fields:
+        :paramtype fields: list[str]
+        """
+        super(HighlightOptions, self).__init__(**kwargs)
+        self.pre_tag = kwargs.get("pre_tag", None)
+        self.post_tag = kwargs.get("post_tag", None)
+        self.fields = kwargs.get("fields", None)
+
+
+class IndependentPipelineAnnotations(msrest.serialization.Model):
+    """IndependentPipelineAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar url: Required.
+    :vartype url: str
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or
+     ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar last_run_id: Required.
+    :vartype last_run_id: str
+    :ivar pipeline_type: Required.
+    :vartype pipeline_type: str
+    :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+     "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+    :vartype last_run_status_code: str or
+     ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode
+    :ivar last_run_creation_time: Required.
+    :vartype last_run_creation_time: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "url": {"required": True},
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "last_run_id": {"required": True},
+        "pipeline_type": {"required": True},
+        "last_run_status_code": {"required": True},
+        "last_run_creation_time": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "url": {"key": "url", "type": "str"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "last_run_id": {"key": "lastRunId", "type": "str"},
+        "pipeline_type": {"key": "pipelineType", "type": "str"},
+        "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"},
+        "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword url: Required.
+        :paramtype url: str
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or
+         ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword last_run_id: Required.
+        :paramtype last_run_id: str
+        :keyword pipeline_type: Required.
+        :paramtype pipeline_type: str
+        :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+         "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+        :paramtype last_run_status_code: str or
+         ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode
+        :keyword last_run_creation_time: Required.
+        :paramtype last_run_creation_time: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(IndependentPipelineAnnotations, self).__init__(**kwargs)
+        self.url = kwargs["url"]
+        self.kv_tags = kwargs["kv_tags"]
+        self.step_tags = kwargs["step_tags"]
+        self.properties = kwargs["properties"]
+        self.step_properties = kwargs["step_properties"]
+        self.entity_status = kwargs["entity_status"]
+        self.last_modified_date = kwargs["last_modified_date"]
+        self.last_updated_by = kwargs["last_updated_by"]
+        self.last_run_id = kwargs["last_run_id"]
+        self.pipeline_type = kwargs["pipeline_type"]
+        self.last_run_status_code = kwargs["last_run_status_code"]
+        self.last_run_creation_time = kwargs["last_run_creation_time"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class IndependentPipelineProperties(msrest.serialization.Model):
+    """IndependentPipelineProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(IndependentPipelineProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class IndependentpipelinesUnversionedEntitiesResponse(msrest.serialization.Model):
+    """IndependentpipelinesUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[IndependentpipelinesUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(IndependentpipelinesUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class IndependentpipelinesUnversionedEntity(msrest.serialization.Model):
+    """IndependentpipelinesUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.IndependentPipelineAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.IndependentPipelineProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "IndependentPipelineAnnotations"},
+        "properties": {"key": "properties", "type": "IndependentPipelineProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.IndependentPipelineAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.IndependentPipelineProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(IndependentpipelinesUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class IndexAnnotations(msrest.serialization.Model):
+    """IndexAnnotations.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar archived:
+    :vartype archived: bool
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword archived:
+        :paramtype archived: bool
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(IndexAnnotations, self).__init__(**kwargs)
+        self.additional_properties = kwargs.get("additional_properties", None)
+        self.archived = kwargs.get("archived", None)
+        self.tags = kwargs.get("tags", None)
+
+
+class IndexColumn(msrest.serialization.Model):
+    """IndexColumn.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+     "Double", "Binary", "Datetime", "Boolean".
+    :vartype data_type: str or ~index_service_apis.models.IndexColumnDataType
+    :ivar column_name: Required.
+    :vartype column_name: str
+    """
+
+    _validation = {
+        "data_type": {"required": True},
+        "column_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "data_type": {"key": "dataType", "type": "str"},
+        "column_name": {"key": "columnName", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+         "Double", "Binary", "Datetime", "Boolean".
+        :paramtype data_type: str or ~index_service_apis.models.IndexColumnDataType
+        :keyword column_name: Required.
+        :paramtype column_name: str
+        """
+        super(IndexColumn, self).__init__(**kwargs)
+        self.data_type = kwargs["data_type"]
+        self.column_name = kwargs["column_name"]
+
+
+class IndexColumnDto(msrest.serialization.Model):
+    """IndexColumnDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar type: Required. Possible values include: "string", "integer", "long", "float", "double",
+     "binary", "datetime", "boolean".
+    :vartype type: str or ~index_service_apis.models.IndexColumnDtoType
+    :ivar name: Required.
+    :vartype name: str
+    """
+
+    _validation = {
+        "type": {"required": True},
+        "name": {"required": True},
+    }
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword type: Required. Possible values include: "string", "integer", "long", "float",
+         "double", "binary", "datetime", "boolean".
+        :paramtype type: str or ~index_service_apis.models.IndexColumnDtoType
+        :keyword name: Required.
+        :paramtype name: str
+        """
+        super(IndexColumnDto, self).__init__(**kwargs)
+        self.type = kwargs["type"]
+        self.name = kwargs["name"]
+
+
+class IndexedErrorResponse(msrest.serialization.Model):
+    """IndexedErrorResponse.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar code: Required.
+    :vartype code: str
+    :ivar error_code_hierarchy: Required.
+    :vartype error_code_hierarchy: str
+    :ivar message: Required.
+    :vartype message: str
+    :ivar time: Required.
+    :vartype time: ~datetime.datetime
+    :ivar component_name: Required.
+    :vartype component_name: str
+    :ivar severity: Required.
+    :vartype severity: int
+    :ivar details_uri: Required.
+    :vartype details_uri: str
+    :ivar reference_code: Required.
+    :vartype reference_code: str
+    """
+
+    _validation = {
+        "code": {"required": True},
+        "error_code_hierarchy": {"required": True},
+        "message": {"required": True},
+        "time": {"required": True},
+        "component_name": {"required": True},
+        "severity": {"required": True},
+        "details_uri": {"required": True},
+        "reference_code": {"required": True},
+    }
+
+    _attribute_map = {
+        "code": {"key": "code", "type": "str"},
+        "error_code_hierarchy": {"key": "errorCodeHierarchy", "type": "str"},
+        "message": {"key": "message", "type": "str"},
+        "time": {"key": "time", "type": "iso-8601"},
+        "component_name": {"key": "componentName", "type": "str"},
+        "severity": {"key": "severity", "type": "int"},
+        "details_uri": {"key": "detailsUri", "type": "str"},
+        "reference_code": {"key": "referenceCode", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword code: Required.
+        :paramtype code: str
+        :keyword error_code_hierarchy: Required.
+        :paramtype error_code_hierarchy: str
+        :keyword message: Required.
+        :paramtype message: str
+        :keyword time: Required.
+        :paramtype time: ~datetime.datetime
+        :keyword component_name: Required.
+        :paramtype component_name: str
+        :keyword severity: Required.
+        :paramtype severity: int
+        :keyword details_uri: Required.
+        :paramtype details_uri: str
+        :keyword reference_code: Required.
+        :paramtype reference_code: str
+        """
+        super(IndexedErrorResponse, self).__init__(**kwargs)
+        self.code = kwargs["code"]
+        self.error_code_hierarchy = kwargs["error_code_hierarchy"]
+        self.message = kwargs["message"]
+        self.time = kwargs["time"]
+        self.component_name = kwargs["component_name"]
+        self.severity = kwargs["severity"]
+        self.details_uri = kwargs["details_uri"]
+        self.reference_code = kwargs["reference_code"]
+
+
+class IndexEntitiesLocalOperationRequest(msrest.serialization.Model):
+    """IndexEntitiesLocalOperationRequest.
+
+    :ivar get_all_entities:
+    :vartype get_all_entities: bool
+    :ivar group:
+    :vartype group: list[~index_service_apis.models.IndexEntitiesRequestGroup]
+    :ivar highlight_options:
+    :vartype highlight_options: ~index_service_apis.models.HighlightOptions
+    :ivar search_builder:
+    :vartype search_builder: str
+    :ivar search_mode:
+    :vartype search_mode: str
+    :ivar free_text_search:
+    :vartype free_text_search: str
+    :ivar free_text_search_columns:
+    :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+    :ivar filters:
+    :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar asset_resource_filters:
+    :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar order:
+    :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+    :ivar page_size:
+    :vartype page_size: int
+    :ivar skip:
+    :vartype skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar include_total_result_count:
+    :vartype include_total_result_count: bool
+    :ivar resources:
+    :vartype resources: list[~index_service_apis.models.ResourceInformation]
+    :ivar cmk_fanout:
+    :vartype cmk_fanout: bool
+    :ivar include_fanout_data:
+    :vartype include_fanout_data: bool
+    :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    """
+
+    _attribute_map = {
+        "get_all_entities": {"key": "getAllEntities", "type": "bool"},
+        "group": {"key": "group", "type": "[IndexEntitiesRequestGroup]"},
+        "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"},
+        "search_builder": {"key": "searchBuilder", "type": "str"},
+        "search_mode": {"key": "searchMode", "type": "str"},
+        "free_text_search": {"key": "freeTextSearch", "type": "str"},
+        "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"},
+        "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"},
+        "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"},
+        "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"},
+        "page_size": {"key": "pageSize", "type": "int"},
+        "skip": {"key": "skip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"},
+        "resources": {"key": "resources", "type": "[ResourceInformation]"},
+        "cmk_fanout": {"key": "cmkFanout", "type": "bool"},
+        "include_fanout_data": {"key": "includeFanoutData", "type": "bool"},
+        "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword get_all_entities:
+        :paramtype get_all_entities: bool
+        :keyword group:
+        :paramtype group: list[~index_service_apis.models.IndexEntitiesRequestGroup]
+        :keyword highlight_options:
+        :paramtype highlight_options: ~index_service_apis.models.HighlightOptions
+        :keyword search_builder:
+        :paramtype search_builder: str
+        :keyword search_mode:
+        :paramtype search_mode: str
+        :keyword free_text_search:
+        :paramtype free_text_search: str
+        :keyword free_text_search_columns:
+        :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+        :keyword filters:
+        :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword asset_resource_filters:
+        :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword order:
+        :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+        :keyword page_size:
+        :paramtype page_size: int
+        :keyword skip:
+        :paramtype skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword include_total_result_count:
+        :paramtype include_total_result_count: bool
+        :keyword resources:
+        :paramtype resources: list[~index_service_apis.models.ResourceInformation]
+        :keyword cmk_fanout:
+        :paramtype cmk_fanout: bool
+        :keyword include_fanout_data:
+        :paramtype include_fanout_data: bool
+        :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        """
+        super(IndexEntitiesLocalOperationRequest, self).__init__(**kwargs)
+        self.get_all_entities = kwargs.get("get_all_entities", None)
+        self.group = kwargs.get("group", None)
+        self.highlight_options = kwargs.get("highlight_options", None)
+        self.search_builder = kwargs.get("search_builder", None)
+        self.search_mode = kwargs.get("search_mode", None)
+        self.free_text_search = kwargs.get("free_text_search", None)
+        self.free_text_search_columns = kwargs.get("free_text_search_columns", None)
+        self.filters = kwargs.get("filters", None)
+        self.asset_resource_filters = kwargs.get("asset_resource_filters", None)
+        self.order = kwargs.get("order", None)
+        self.page_size = kwargs.get("page_size", None)
+        self.skip = kwargs.get("skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.include_total_result_count = kwargs.get("include_total_result_count", None)
+        self.resources = kwargs.get("resources", None)
+        self.cmk_fanout = kwargs.get("cmk_fanout", None)
+        self.include_fanout_data = kwargs.get("include_fanout_data", None)
+        self.shard_id_to_shard_skips = kwargs.get("shard_id_to_shard_skips", None)
+
+
+class IndexEntitiesRequest(msrest.serialization.Model):
+    """IndexEntitiesRequest.
+
+    :ivar highlight_options:
+    :vartype highlight_options: ~index_service_apis.models.HighlightOptions
+    :ivar search_builder:
+    :vartype search_builder: str
+    :ivar search_mode:
+    :vartype search_mode: str
+    :ivar free_text_search:
+    :vartype free_text_search: str
+    :ivar free_text_search_columns:
+    :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+    :ivar filters:
+    :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar asset_resource_filters:
+    :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar order:
+    :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+    :ivar page_size:
+    :vartype page_size: int
+    :ivar skip:
+    :vartype skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar include_total_result_count:
+    :vartype include_total_result_count: bool
+    :ivar resources:
+    :vartype resources: list[~index_service_apis.models.ResourceInformation]
+    :ivar cmk_fanout:
+    :vartype cmk_fanout: bool
+    :ivar include_fanout_data:
+    :vartype include_fanout_data: bool
+    :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    """
+
+    _attribute_map = {
+        "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"},
+        "search_builder": {"key": "searchBuilder", "type": "str"},
+        "search_mode": {"key": "searchMode", "type": "str"},
+        "free_text_search": {"key": "freeTextSearch", "type": "str"},
+        "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"},
+        "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"},
+        "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"},
+        "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"},
+        "page_size": {"key": "pageSize", "type": "int"},
+        "skip": {"key": "skip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"},
+        "resources": {"key": "resources", "type": "[ResourceInformation]"},
+        "cmk_fanout": {"key": "cmkFanout", "type": "bool"},
+        "include_fanout_data": {"key": "includeFanoutData", "type": "bool"},
+        "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword highlight_options:
+        :paramtype highlight_options: ~index_service_apis.models.HighlightOptions
+        :keyword search_builder:
+        :paramtype search_builder: str
+        :keyword search_mode:
+        :paramtype search_mode: str
+        :keyword free_text_search:
+        :paramtype free_text_search: str
+        :keyword free_text_search_columns:
+        :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+        :keyword filters:
+        :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword asset_resource_filters:
+        :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword order:
+        :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+        :keyword page_size:
+        :paramtype page_size: int
+        :keyword skip:
+        :paramtype skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword include_total_result_count:
+        :paramtype include_total_result_count: bool
+        :keyword resources:
+        :paramtype resources: list[~index_service_apis.models.ResourceInformation]
+        :keyword cmk_fanout:
+        :paramtype cmk_fanout: bool
+        :keyword include_fanout_data:
+        :paramtype include_fanout_data: bool
+        :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        """
+        super(IndexEntitiesRequest, self).__init__(**kwargs)
+        self.highlight_options = kwargs.get("highlight_options", None)
+        self.search_builder = kwargs.get("search_builder", None)
+        self.search_mode = kwargs.get("search_mode", None)
+        self.free_text_search = kwargs.get("free_text_search", None)
+        self.free_text_search_columns = kwargs.get("free_text_search_columns", None)
+        self.filters = kwargs.get("filters", None)
+        self.asset_resource_filters = kwargs.get("asset_resource_filters", None)
+        self.order = kwargs.get("order", None)
+        self.page_size = kwargs.get("page_size", None)
+        self.skip = kwargs.get("skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.include_total_result_count = kwargs.get("include_total_result_count", None)
+        self.resources = kwargs.get("resources", None)
+        self.cmk_fanout = kwargs.get("cmk_fanout", None)
+        self.include_fanout_data = kwargs.get("include_fanout_data", None)
+        self.shard_id_to_shard_skips = kwargs.get("shard_id_to_shard_skips", None)
+
+
+class IndexEntitiesRequestFilter(msrest.serialization.Model):
+    """IndexEntitiesRequestFilter.
+
+    :ivar field:
+    :vartype field: str
+    :ivar operator:
+    :vartype operator: str
+    :ivar values:
+    :vartype values: list[str]
+    """
+
+    _attribute_map = {
+        "field": {"key": "field", "type": "str"},
+        "operator": {"key": "operator", "type": "str"},
+        "values": {"key": "values", "type": "[str]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword field:
+        :paramtype field: str
+        :keyword operator:
+        :paramtype operator: str
+        :keyword values:
+        :paramtype values: list[str]
+        """
+        super(IndexEntitiesRequestFilter, self).__init__(**kwargs)
+        self.field = kwargs.get("field", None)
+        self.operator = kwargs.get("operator", None)
+        self.values = kwargs.get("values", None)
+
+
+class IndexEntitiesRequestGroup(msrest.serialization.Model):
+    """IndexEntitiesRequestGroup.
+
+    :ivar field:
+    :vartype field: str
+    """
+
+    _attribute_map = {
+        "field": {"key": "field", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword field:
+        :paramtype field: str
+        """
+        super(IndexEntitiesRequestGroup, self).__init__(**kwargs)
+        self.field = kwargs.get("field", None)
+
+
+class IndexEntitiesRequestOrder(msrest.serialization.Model):
+    """IndexEntitiesRequestOrder.
+
+    :ivar field:
+    :vartype field: str
+    :ivar direction: Possible values include: "Asc", "Desc".
+    :vartype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection
+    """
+
+    _attribute_map = {
+        "field": {"key": "field", "type": "str"},
+        "direction": {"key": "direction", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword field:
+        :paramtype field: str
+        :keyword direction: Possible values include: "Asc", "Desc".
+        :paramtype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection
+        """
+        super(IndexEntitiesRequestOrder, self).__init__(**kwargs)
+        self.field = kwargs.get("field", None)
+        self.direction = kwargs.get("direction", None)
+
+
+class IndexEntitiesResponse(msrest.serialization.Model):
+    """IndexEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.IndexEntityResponse]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[IndexEntityResponse]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.IndexEntityResponse]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(IndexEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class IndexEntityContainerMetadata(msrest.serialization.Model):
+    """IndexEntityContainerMetadata.
+
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group:
+    :vartype resource_group: str
+    :ivar resource_name:
+    :vartype resource_name: str
+    :ivar entity_container_type:
+    :vartype entity_container_type: str
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    :ivar tenant_id:
+    :vartype tenant_id: str
+    :ivar immutable_resource_id:
+    :vartype immutable_resource_id: str
+    :ivar is_public_resource:
+    :vartype is_public_resource: bool
+    """
+
+    _attribute_map = {
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group": {"key": "resourceGroup", "type": "str"},
+        "resource_name": {"key": "resourceName", "type": "str"},
+        "entity_container_type": {"key": "entityContainerType", "type": "str"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+        "tenant_id": {"key": "tenantId", "type": "str"},
+        "immutable_resource_id": {"key": "immutableResourceId", "type": "str"},
+        "is_public_resource": {"key": "isPublicResource", "type": "bool"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group:
+        :paramtype resource_group: str
+        :keyword resource_name:
+        :paramtype resource_name: str
+        :keyword entity_container_type:
+        :paramtype entity_container_type: str
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        :keyword tenant_id:
+        :paramtype tenant_id: str
+        :keyword immutable_resource_id:
+        :paramtype immutable_resource_id: str
+        :keyword is_public_resource:
+        :paramtype is_public_resource: bool
+        """
+        super(IndexEntityContainerMetadata, self).__init__(**kwargs)
+        self.resource_id = kwargs.get("resource_id", None)
+        self.subscription_id = kwargs.get("subscription_id", None)
+        self.resource_group = kwargs.get("resource_group", None)
+        self.resource_name = kwargs.get("resource_name", None)
+        self.entity_container_type = kwargs.get("entity_container_type", None)
+        self.regions = kwargs.get("regions", None)
+        self.tenant_id = kwargs.get("tenant_id", None)
+        self.immutable_resource_id = kwargs.get("immutable_resource_id", None)
+        self.is_public_resource = kwargs.get("is_public_resource", None)
+
+
+class IndexEntityResponse(msrest.serialization.Model):
+    """IndexEntityResponse.
+
+    Variables are only populated by the server, and will be ignored when sending a request.
+
+    :ivar relevancy_score:
+    :vartype relevancy_score: float
+    :ivar entity_resource_name:
+    :vartype entity_resource_name: str
+    :ivar highlights: Dictionary of
+     <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>.
+    :vartype highlights: dict[str, list[str]]
+    :ivar usage:
+    :vartype usage: ~index_service_apis.models.Usage
+    :ivar schema_id:
+    :vartype schema_id: str
+    :ivar entity_id:
+    :vartype entity_id: str
+    :ivar kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.EntityKind
+    :ivar annotations:
+    :vartype annotations: ~index_service_apis.models.IndexAnnotations
+    :ivar properties:
+    :vartype properties: ~index_service_apis.models.IndexProperties
+    :ivar internal: Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence:
+    :vartype update_sequence: long
+    :ivar type:
+    :vartype type: str
+    :ivar version:
+    :vartype version: str
+    :ivar entity_container_id:
+    :vartype entity_container_id: str
+    :ivar entity_object_id:
+    :vartype entity_object_id: str
+    :ivar resource_type:
+    :vartype resource_type: str
+    :ivar relationships:
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "version": {"readonly": True},
+        "entity_container_id": {"readonly": True},
+        "entity_object_id": {"readonly": True},
+        "resource_type": {"readonly": True},
+    }
+
+    _attribute_map = {
+        "relevancy_score": {"key": "relevancyScore", "type": "float"},
+        "entity_resource_name": {"key": "entityResourceName", "type": "str"},
+        "highlights": {"key": "highlights", "type": "{[str]}"},
+        "usage": {"key": "usage", "type": "Usage"},
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "IndexAnnotations"},
+        "properties": {"key": "properties", "type": "IndexProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "long"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword relevancy_score:
+        :paramtype relevancy_score: float
+        :keyword entity_resource_name:
+        :paramtype entity_resource_name: str
+        :keyword highlights: Dictionary of
+         <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>.
+        :paramtype highlights: dict[str, list[str]]
+        :keyword usage:
+        :paramtype usage: ~index_service_apis.models.Usage
+        :keyword schema_id:
+        :paramtype schema_id: str
+        :keyword entity_id:
+        :paramtype entity_id: str
+        :keyword kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.EntityKind
+        :keyword annotations:
+        :paramtype annotations: ~index_service_apis.models.IndexAnnotations
+        :keyword properties:
+        :paramtype properties: ~index_service_apis.models.IndexProperties
+        :keyword internal: Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence:
+        :paramtype update_sequence: long
+        :keyword type:
+        :paramtype type: str
+        :keyword relationships:
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(IndexEntityResponse, self).__init__(**kwargs)
+        self.relevancy_score = kwargs.get("relevancy_score", None)
+        self.entity_resource_name = kwargs.get("entity_resource_name", None)
+        self.highlights = kwargs.get("highlights", None)
+        self.usage = kwargs.get("usage", None)
+        self.schema_id = kwargs.get("schema_id", None)
+        self.entity_id = kwargs.get("entity_id", None)
+        self.kind = kwargs.get("kind", None)
+        self.annotations = kwargs.get("annotations", None)
+        self.properties = kwargs.get("properties", None)
+        self.internal = kwargs.get("internal", None)
+        self.update_sequence = kwargs.get("update_sequence", None)
+        self.type = kwargs.get("type", None)
+        self.version = None
+        self.entity_container_id = None
+        self.entity_object_id = None
+        self.resource_type = None
+        self.relationships = kwargs.get("relationships", None)
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class IndexProperties(msrest.serialization.Model):
+    """IndexProperties.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar updated_time:
+    :vartype updated_time: ~datetime.datetime
+    :ivar creation_context:
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "updated_time": {"key": "updatedTime", "type": "iso-8601"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword updated_time:
+        :paramtype updated_time: ~datetime.datetime
+        :keyword creation_context:
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(IndexProperties, self).__init__(**kwargs)
+        self.additional_properties = kwargs.get("additional_properties", None)
+        self.updated_time = kwargs.get("updated_time", None)
+        self.creation_context = kwargs.get("creation_context", None)
+
+
+class IndexResourceDiscoveryResponseItem(msrest.serialization.Model):
+    """IndexResourceDiscoveryResponseItem.
+
+    :ivar name:
+    :vartype name: str
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar resource_type:
+    :vartype resource_type: str
+    :ivar region:
+    :vartype region: str
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group_name:
+    :vartype resource_group_name: str
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    :ivar is_customer_managed:
+    :vartype is_customer_managed: bool
+    :ivar is_private_link_resource:
+    :vartype is_private_link_resource: bool
+    :ivar is_private_link_resource_behind_vnet:
+    :vartype is_private_link_resource_behind_vnet: bool
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "region": {"key": "region", "type": "str"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group_name": {"key": "resourceGroupName", "type": "str"},
+        "tags": {"key": "tags", "type": "{str}"},
+        "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"},
+        "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"},
+        "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name:
+        :paramtype name: str
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword resource_type:
+        :paramtype resource_type: str
+        :keyword region:
+        :paramtype region: str
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group_name:
+        :paramtype resource_group_name: str
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        :keyword is_customer_managed:
+        :paramtype is_customer_managed: bool
+        :keyword is_private_link_resource:
+        :paramtype is_private_link_resource: bool
+        :keyword is_private_link_resource_behind_vnet:
+        :paramtype is_private_link_resource_behind_vnet: bool
+        """
+        super(IndexResourceDiscoveryResponseItem, self).__init__(**kwargs)
+        self.name = kwargs.get("name", None)
+        self.resource_id = kwargs.get("resource_id", None)
+        self.resource_type = kwargs.get("resource_type", None)
+        self.region = kwargs.get("region", None)
+        self.regions = kwargs.get("regions", None)
+        self.subscription_id = kwargs.get("subscription_id", None)
+        self.resource_group_name = kwargs.get("resource_group_name", None)
+        self.tags = kwargs.get("tags", None)
+        self.is_customer_managed = kwargs.get("is_customer_managed", None)
+        self.is_private_link_resource = kwargs.get("is_private_link_resource", None)
+        self.is_private_link_resource_behind_vnet = kwargs.get("is_private_link_resource_behind_vnet", None)
+
+
+class IndexResourceDiscoveryResponseItemPaginatedResult(msrest.serialization.Model):
+    """IndexResourceDiscoveryResponseItemPaginatedResult.
+
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem]
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar next_link:
+    :vartype next_link: str
+    """
+
+    _attribute_map = {
+        "value": {"key": "value", "type": "[IndexResourceDiscoveryResponseItem]"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "next_link": {"key": "nextLink", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem]
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword next_link:
+        :paramtype next_link: str
+        """
+        super(IndexResourceDiscoveryResponseItemPaginatedResult, self).__init__(**kwargs)
+        self.value = kwargs.get("value", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.next_link = kwargs.get("next_link", None)
+
+
+class InnerErrorResponse(msrest.serialization.Model):
+    """InnerErrorResponse.
+
+    :ivar code:
+    :vartype code: str
+    :ivar inner_error:
+    :vartype inner_error: ~index_service_apis.models.InnerErrorResponse
+    """
+
+    _attribute_map = {
+        "code": {"key": "code", "type": "str"},
+        "inner_error": {"key": "innerError", "type": "InnerErrorResponse"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword code:
+        :paramtype code: str
+        :keyword inner_error:
+        :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse
+        """
+        super(InnerErrorResponse, self).__init__(**kwargs)
+        self.code = kwargs.get("code", None)
+        self.inner_error = kwargs.get("inner_error", None)
+
+
+class InputNameAndDataTypeIdsList(msrest.serialization.Model):
+    """InputNameAndDataTypeIdsList.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar data_type_ids_list: Required.
+    :vartype data_type_ids_list: list[str]
+    :ivar is_optional: Required.
+    :vartype is_optional: bool
+    :ivar description: Required.
+    :vartype description: str
+    :ivar label: Required.
+    :vartype label: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "data_type_ids_list": {"required": True},
+        "is_optional": {"required": True},
+        "description": {"required": True},
+        "label": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "data_type_ids_list": {"key": "dataTypeIdsList", "type": "[str]"},
+        "is_optional": {"key": "isOptional", "type": "bool"},
+        "description": {"key": "description", "type": "str"},
+        "label": {"key": "label", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword data_type_ids_list: Required.
+        :paramtype data_type_ids_list: list[str]
+        :keyword is_optional: Required.
+        :paramtype is_optional: bool
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword label: Required.
+        :paramtype label: str
+        """
+        super(InputNameAndDataTypeIdsList, self).__init__(**kwargs)
+        self.name = kwargs["name"]
+        self.data_type_ids_list = kwargs["data_type_ids_list"]
+        self.is_optional = kwargs["is_optional"]
+        self.description = kwargs["description"]
+        self.label = kwargs["label"]
+
+
+class InternalUxPresenceWarmUpRequest(msrest.serialization.Model):
+    """InternalUxPresenceWarmUpRequest.
+
+    :ivar resources:
+    :vartype resources: list[~index_service_apis.models.UxPresenceResource]
+    :ivar source_ip:
+    :vartype source_ip: str
+    :ivar user_tenant_id:
+    :vartype user_tenant_id: str
+    :ivar user_object_id:
+    :vartype user_object_id: str
+    """
+
+    _attribute_map = {
+        "resources": {"key": "resources", "type": "[UxPresenceResource]"},
+        "source_ip": {"key": "sourceIp", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword resources:
+        :paramtype resources: list[~index_service_apis.models.UxPresenceResource]
+        :keyword source_ip:
+        :paramtype source_ip: str
+        :keyword user_tenant_id:
+        :paramtype user_tenant_id: str
+        :keyword user_object_id:
+        :paramtype user_object_id: str
+        """
+        super(InternalUxPresenceWarmUpRequest, self).__init__(**kwargs)
+        self.resources = kwargs.get("resources", None)
+        self.source_ip = kwargs.get("source_ip", None)
+        self.user_tenant_id = kwargs.get("user_tenant_id", None)
+        self.user_object_id = kwargs.get("user_object_id", None)
+
+
+class JobCost(msrest.serialization.Model):
+    """JobCost.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar charged_cpu_core_seconds: Required.
+    :vartype charged_cpu_core_seconds: float
+    :ivar charged_cpu_memory_megabyte_seconds: Required.
+    :vartype charged_cpu_memory_megabyte_seconds: float
+    :ivar charged_gpu_seconds: Required.
+    :vartype charged_gpu_seconds: float
+    :ivar charged_node_utilization_seconds: Required.
+    :vartype charged_node_utilization_seconds: float
+    """
+
+    _validation = {
+        "charged_cpu_core_seconds": {"required": True},
+        "charged_cpu_memory_megabyte_seconds": {"required": True},
+        "charged_gpu_seconds": {"required": True},
+        "charged_node_utilization_seconds": {"required": True},
+    }
+
+    _attribute_map = {
+        "charged_cpu_core_seconds": {"key": "chargedCpuCoreSeconds", "type": "float"},
+        "charged_cpu_memory_megabyte_seconds": {"key": "chargedCpuMemoryMegabyteSeconds", "type": "float"},
+        "charged_gpu_seconds": {"key": "chargedGpuSeconds", "type": "float"},
+        "charged_node_utilization_seconds": {"key": "chargedNodeUtilizationSeconds", "type": "float"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword charged_cpu_core_seconds: Required.
+        :paramtype charged_cpu_core_seconds: float
+        :keyword charged_cpu_memory_megabyte_seconds: Required.
+        :paramtype charged_cpu_memory_megabyte_seconds: float
+        :keyword charged_gpu_seconds: Required.
+        :paramtype charged_gpu_seconds: float
+        :keyword charged_node_utilization_seconds: Required.
+        :paramtype charged_node_utilization_seconds: float
+        """
+        super(JobCost, self).__init__(**kwargs)
+        self.charged_cpu_core_seconds = kwargs["charged_cpu_core_seconds"]
+        self.charged_cpu_memory_megabyte_seconds = kwargs["charged_cpu_memory_megabyte_seconds"]
+        self.charged_gpu_seconds = kwargs["charged_gpu_seconds"]
+        self.charged_node_utilization_seconds = kwargs["charged_node_utilization_seconds"]
+
+
+class MaterializationComputeResource(msrest.serialization.Model):
+    """MaterializationComputeResource.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar instance_type: Required.
+    :vartype instance_type: str
+    """
+
+    _validation = {
+        "instance_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "instance_type": {"key": "instanceType", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword instance_type: Required.
+        :paramtype instance_type: str
+        """
+        super(MaterializationComputeResource, self).__init__(**kwargs)
+        self.instance_type = kwargs["instance_type"]
+
+
+class MaterializationSettings(msrest.serialization.Model):
+    """MaterializationSettings.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar materialization_store_type: Required. Possible values include: "None", "Online",
+     "Offline", "OnlineAndOffline".
+    :vartype materialization_store_type: str or
+     ~index_service_apis.models.MaterializationSettingsMaterializationStoreType
+    :ivar schedule: Required.
+    :vartype schedule: ~index_service_apis.models.Recurrence
+    :ivar notification:
+    :vartype notification: ~index_service_apis.models.NotificationSetting
+    :ivar resource: Required.
+    :vartype resource: ~index_service_apis.models.MaterializationComputeResource
+    :ivar spark_configuration: Required. Dictionary of :code:`<string>`.
+    :vartype spark_configuration: dict[str, str]
+    """
+
+    _validation = {
+        "materialization_store_type": {"required": True},
+        "schedule": {"required": True},
+        "resource": {"required": True},
+        "spark_configuration": {"required": True},
+    }
+
+    _attribute_map = {
+        "materialization_store_type": {"key": "materializationStoreType", "type": "str"},
+        "schedule": {"key": "schedule", "type": "Recurrence"},
+        "notification": {"key": "notification", "type": "NotificationSetting"},
+        "resource": {"key": "resource", "type": "MaterializationComputeResource"},
+        "spark_configuration": {"key": "sparkConfiguration", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword materialization_store_type: Required. Possible values include: "None", "Online",
+         "Offline", "OnlineAndOffline".
+        :paramtype materialization_store_type: str or
+         ~index_service_apis.models.MaterializationSettingsMaterializationStoreType
+        :keyword schedule: Required.
+        :paramtype schedule: ~index_service_apis.models.Recurrence
+        :keyword notification:
+        :paramtype notification: ~index_service_apis.models.NotificationSetting
+        :keyword resource: Required.
+        :paramtype resource: ~index_service_apis.models.MaterializationComputeResource
+        :keyword spark_configuration: Required. Dictionary of :code:`<string>`.
+        :paramtype spark_configuration: dict[str, str]
+        """
+        super(MaterializationSettings, self).__init__(**kwargs)
+        self.materialization_store_type = kwargs["materialization_store_type"]
+        self.schedule = kwargs["schedule"]
+        self.notification = kwargs.get("notification", None)
+        self.resource = kwargs["resource"]
+        self.spark_configuration = kwargs["spark_configuration"]
+
+
+class ModelAnnotations(msrest.serialization.Model):
+    """ModelAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar datasets: Required.
+    :vartype datasets: list[~index_service_apis.models.DatasetReference]
+    :ivar sample_input_data: Required.
+    :vartype sample_input_data: str
+    :ivar sample_output_data: Required.
+    :vartype sample_output_data: str
+    :ivar resource_requirements: Required.
+    :vartype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "datasets": {"required": True},
+        "sample_input_data": {"required": True},
+        "sample_output_data": {"required": True},
+        "resource_requirements": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "datasets": {"key": "datasets", "type": "[DatasetReference]"},
+        "sample_input_data": {"key": "sampleInputData", "type": "str"},
+        "sample_output_data": {"key": "sampleOutputData", "type": "str"},
+        "resource_requirements": {"key": "resourceRequirements", "type": "ContainerResourceRequirements"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword datasets: Required.
+        :paramtype datasets: list[~index_service_apis.models.DatasetReference]
+        :keyword sample_input_data: Required.
+        :paramtype sample_input_data: str
+        :keyword sample_output_data: Required.
+        :paramtype sample_output_data: str
+        :keyword resource_requirements: Required.
+        :paramtype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(ModelAnnotations, self).__init__(**kwargs)
+        self.datasets = kwargs["datasets"]
+        self.sample_input_data = kwargs["sample_input_data"]
+        self.sample_output_data = kwargs["sample_output_data"]
+        self.resource_requirements = kwargs["resource_requirements"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class ModelProperties(msrest.serialization.Model):
+    """ModelProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar model_framework: Required.
+    :vartype model_framework: str
+    :ivar model_framework_version: Required.
+    :vartype model_framework_version: str
+    :ivar model_format: Required.
+    :vartype model_format: str
+    :ivar version: Required.
+    :vartype version: int
+    :ivar alphanumeric_version: Required.
+    :vartype alphanumeric_version: str
+    :ivar url: Required.
+    :vartype url: str
+    :ivar mime_type: Required.
+    :vartype mime_type: str
+    :ivar modified_time: Required.
+    :vartype modified_time: ~datetime.datetime
+    :ivar unpack: Required.
+    :vartype unpack: bool
+    :ivar parent_model_id: Required.
+    :vartype parent_model_id: str
+    :ivar run_id: Required.
+    :vartype run_id: str
+    :ivar experiment_name: Required.
+    :vartype experiment_name: str
+    :ivar experiment_id: Required.
+    :vartype experiment_id: str
+    :ivar derived_model_ids: Required.
+    :vartype derived_model_ids: list[str]
+    :ivar user_properties: Required. Dictionary of :code:`<string>`.
+    :vartype user_properties: dict[str, str]
+    :ivar is_anonymous: Required.
+    :vartype is_anonymous: bool
+    :ivar orgin_asset_id: Required.
+    :vartype orgin_asset_id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "name": {"required": True},
+        "model_framework": {"required": True},
+        "model_framework_version": {"required": True},
+        "model_format": {"required": True},
+        "version": {"required": True},
+        "alphanumeric_version": {"required": True},
+        "url": {"required": True},
+        "mime_type": {"required": True},
+        "modified_time": {"required": True},
+        "unpack": {"required": True},
+        "parent_model_id": {"required": True},
+        "run_id": {"required": True},
+        "experiment_name": {"required": True},
+        "experiment_id": {"required": True},
+        "derived_model_ids": {"required": True},
+        "user_properties": {"required": True},
+        "is_anonymous": {"required": True},
+        "orgin_asset_id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "model_framework": {"key": "modelFramework", "type": "str"},
+        "model_framework_version": {"key": "modelFrameworkVersion", "type": "str"},
+        "model_format": {"key": "modelFormat", "type": "str"},
+        "version": {"key": "version", "type": "int"},
+        "alphanumeric_version": {"key": "alphanumericVersion", "type": "str"},
+        "url": {"key": "url", "type": "str"},
+        "mime_type": {"key": "mimeType", "type": "str"},
+        "modified_time": {"key": "modifiedTime", "type": "iso-8601"},
+        "unpack": {"key": "unpack", "type": "bool"},
+        "parent_model_id": {"key": "parentModelId", "type": "str"},
+        "run_id": {"key": "runId", "type": "str"},
+        "experiment_name": {"key": "experimentName", "type": "str"},
+        "experiment_id": {"key": "experimentId", "type": "str"},
+        "derived_model_ids": {"key": "derivedModelIds", "type": "[str]"},
+        "user_properties": {"key": "userProperties", "type": "{str}"},
+        "is_anonymous": {"key": "isAnonymous", "type": "bool"},
+        "orgin_asset_id": {"key": "orginAssetId", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword model_framework: Required.
+        :paramtype model_framework: str
+        :keyword model_framework_version: Required.
+        :paramtype model_framework_version: str
+        :keyword model_format: Required.
+        :paramtype model_format: str
+        :keyword version: Required.
+        :paramtype version: int
+        :keyword alphanumeric_version: Required.
+        :paramtype alphanumeric_version: str
+        :keyword url: Required.
+        :paramtype url: str
+        :keyword mime_type: Required.
+        :paramtype mime_type: str
+        :keyword modified_time: Required.
+        :paramtype modified_time: ~datetime.datetime
+        :keyword unpack: Required.
+        :paramtype unpack: bool
+        :keyword parent_model_id: Required.
+        :paramtype parent_model_id: str
+        :keyword run_id: Required.
+        :paramtype run_id: str
+        :keyword experiment_name: Required.
+        :paramtype experiment_name: str
+        :keyword experiment_id: Required.
+        :paramtype experiment_id: str
+        :keyword derived_model_ids: Required.
+        :paramtype derived_model_ids: list[str]
+        :keyword user_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype user_properties: dict[str, str]
+        :keyword is_anonymous: Required.
+        :paramtype is_anonymous: bool
+        :keyword orgin_asset_id: Required.
+        :paramtype orgin_asset_id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(ModelProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.name = kwargs["name"]
+        self.model_framework = kwargs["model_framework"]
+        self.model_framework_version = kwargs["model_framework_version"]
+        self.model_format = kwargs["model_format"]
+        self.version = kwargs["version"]
+        self.alphanumeric_version = kwargs["alphanumeric_version"]
+        self.url = kwargs["url"]
+        self.mime_type = kwargs["mime_type"]
+        self.modified_time = kwargs["modified_time"]
+        self.unpack = kwargs["unpack"]
+        self.parent_model_id = kwargs["parent_model_id"]
+        self.run_id = kwargs["run_id"]
+        self.experiment_name = kwargs["experiment_name"]
+        self.experiment_id = kwargs["experiment_id"]
+        self.derived_model_ids = kwargs["derived_model_ids"]
+        self.user_properties = kwargs["user_properties"]
+        self.is_anonymous = kwargs["is_anonymous"]
+        self.orgin_asset_id = kwargs["orgin_asset_id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class ModelsVersionedEntitiesResponse(msrest.serialization.Model):
+    """ModelsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.ModelsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[ModelsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.ModelsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(ModelsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class ModelsVersionedEntity(msrest.serialization.Model):
+    """ModelsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.ModelAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.ModelProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "ModelAnnotations"},
+        "properties": {"key": "properties", "type": "ModelProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.ModelAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.ModelProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(ModelsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class ModuleAnnotations(msrest.serialization.Model):
+    """ModuleAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar module_name: Required.
+    :vartype module_name: str
+    :ivar display_name: Required.
+    :vartype display_name: str
+    :ivar lower_name: Required.
+    :vartype lower_name: str
+    :ivar module_version: Required.
+    :vartype module_version: str
+    :ivar inputs: Required.
+    :vartype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList]
+    :ivar outputs: Required.
+    :vartype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId]
+    :ivar category: Required.
+    :vartype category: str
+    :ivar step_type: Required.
+    :vartype step_type: str
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus
+    :ivar is_deterministic: Required.
+    :vartype is_deterministic: bool
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar component_type_version: Required.
+    :vartype component_type_version: str
+    :ivar snapshot_id: Required.
+    :vartype snapshot_id: str
+    :ivar runconfig: Required.
+    :vartype runconfig: str
+    :ivar control_outputs: Required.
+    :vartype control_outputs: list[~index_service_apis.models.ControlOutput]
+    :ivar parameters: Required.
+    :vartype parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+    :ivar metadata_parameters: Required.
+    :vartype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+    :ivar aml_module_name: Required.
+    :vartype aml_module_name: str
+    :ivar aml_module_entity_status: Required. Possible values include: "Active", "Deprecated",
+     "Disabled".
+    :vartype aml_module_entity_status: str or
+     ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus
+    :ivar module_type: Required. Possible values include: "User", "Builtin".
+    :vartype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType
+    :ivar module_execution_type: Required.
+    :vartype module_execution_type: str
+    :ivar arguments_serialized: Required.
+    :vartype arguments_serialized: str
+    :ivar cloud_settings_serialized: Required.
+    :vartype cloud_settings_serialized: str
+    :ivar stage: Required.
+    :vartype stage: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "module_name": {"required": True},
+        "display_name": {"required": True},
+        "lower_name": {"required": True},
+        "module_version": {"required": True},
+        "inputs": {"required": True},
+        "outputs": {"required": True},
+        "category": {"required": True},
+        "step_type": {"required": True},
+        "entity_status": {"required": True},
+        "is_deterministic": {"required": True},
+        "kv_tags": {"required": True},
+        "properties": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "component_type_version": {"required": True},
+        "snapshot_id": {"required": True},
+        "runconfig": {"required": True},
+        "control_outputs": {"required": True},
+        "parameters": {"required": True},
+        "metadata_parameters": {"required": True},
+        "aml_module_name": {"required": True},
+        "aml_module_entity_status": {"required": True},
+        "module_type": {"required": True},
+        "module_execution_type": {"required": True},
+        "arguments_serialized": {"required": True},
+        "cloud_settings_serialized": {"required": True},
+        "stage": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "module_name": {"key": "moduleName", "type": "str"},
+        "display_name": {"key": "displayName", "type": "str"},
+        "lower_name": {"key": "lowerName", "type": "str"},
+        "module_version": {"key": "moduleVersion", "type": "str"},
+        "inputs": {"key": "inputs", "type": "[InputNameAndDataTypeIdsList]"},
+        "outputs": {"key": "outputs", "type": "[OutputNameAndDataTypeId]"},
+        "category": {"key": "category", "type": "str"},
+        "step_type": {"key": "stepType", "type": "str"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "is_deterministic": {"key": "isDeterministic", "type": "bool"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "component_type_version": {"key": "componentTypeVersion", "type": "str"},
+        "snapshot_id": {"key": "snapshotId", "type": "str"},
+        "runconfig": {"key": "runconfig", "type": "str"},
+        "control_outputs": {"key": "controlOutputs", "type": "[ControlOutput]"},
+        "parameters": {"key": "parameters", "type": "[StructuredInterfaceParameter]"},
+        "metadata_parameters": {"key": "metadataParameters", "type": "[StructuredInterfaceParameter]"},
+        "aml_module_name": {"key": "amlModuleName", "type": "str"},
+        "aml_module_entity_status": {"key": "amlModuleEntityStatus", "type": "str"},
+        "module_type": {"key": "moduleType", "type": "str"},
+        "module_execution_type": {"key": "moduleExecutionType", "type": "str"},
+        "arguments_serialized": {"key": "argumentsSerialized", "type": "str"},
+        "cloud_settings_serialized": {"key": "cloudSettingsSerialized", "type": "str"},
+        "stage": {"key": "stage", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword module_name: Required.
+        :paramtype module_name: str
+        :keyword display_name: Required.
+        :paramtype display_name: str
+        :keyword lower_name: Required.
+        :paramtype lower_name: str
+        :keyword module_version: Required.
+        :paramtype module_version: str
+        :keyword inputs: Required.
+        :paramtype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList]
+        :keyword outputs: Required.
+        :paramtype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId]
+        :keyword category: Required.
+        :paramtype category: str
+        :keyword step_type: Required.
+        :paramtype step_type: str
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus
+        :keyword is_deterministic: Required.
+        :paramtype is_deterministic: bool
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword component_type_version: Required.
+        :paramtype component_type_version: str
+        :keyword snapshot_id: Required.
+        :paramtype snapshot_id: str
+        :keyword runconfig: Required.
+        :paramtype runconfig: str
+        :keyword control_outputs: Required.
+        :paramtype control_outputs: list[~index_service_apis.models.ControlOutput]
+        :keyword parameters: Required.
+        :paramtype parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+        :keyword metadata_parameters: Required.
+        :paramtype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+        :keyword aml_module_name: Required.
+        :paramtype aml_module_name: str
+        :keyword aml_module_entity_status: Required. Possible values include: "Active", "Deprecated",
+         "Disabled".
+        :paramtype aml_module_entity_status: str or
+         ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus
+        :keyword module_type: Required. Possible values include: "User", "Builtin".
+        :paramtype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType
+        :keyword module_execution_type: Required.
+        :paramtype module_execution_type: str
+        :keyword arguments_serialized: Required.
+        :paramtype arguments_serialized: str
+        :keyword cloud_settings_serialized: Required.
+        :paramtype cloud_settings_serialized: str
+        :keyword stage: Required.
+        :paramtype stage: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(ModuleAnnotations, self).__init__(**kwargs)
+        self.module_name = kwargs["module_name"]
+        self.display_name = kwargs["display_name"]
+        self.lower_name = kwargs["lower_name"]
+        self.module_version = kwargs["module_version"]
+        self.inputs = kwargs["inputs"]
+        self.outputs = kwargs["outputs"]
+        self.category = kwargs["category"]
+        self.step_type = kwargs["step_type"]
+        self.entity_status = kwargs["entity_status"]
+        self.is_deterministic = kwargs["is_deterministic"]
+        self.kv_tags = kwargs["kv_tags"]
+        self.properties = kwargs["properties"]
+        self.last_modified_date = kwargs["last_modified_date"]
+        self.last_updated_by = kwargs["last_updated_by"]
+        self.component_type_version = kwargs["component_type_version"]
+        self.snapshot_id = kwargs["snapshot_id"]
+        self.runconfig = kwargs["runconfig"]
+        self.control_outputs = kwargs["control_outputs"]
+        self.parameters = kwargs["parameters"]
+        self.metadata_parameters = kwargs["metadata_parameters"]
+        self.aml_module_name = kwargs["aml_module_name"]
+        self.aml_module_entity_status = kwargs["aml_module_entity_status"]
+        self.module_type = kwargs["module_type"]
+        self.module_execution_type = kwargs["module_execution_type"]
+        self.arguments_serialized = kwargs["arguments_serialized"]
+        self.cloud_settings_serialized = kwargs["cloud_settings_serialized"]
+        self.stage = kwargs["stage"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class ModuleProperties(msrest.serialization.Model):
+    """ModuleProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar aml_module_id: Required.
+    :vartype aml_module_id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "aml_module_id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "aml_module_id": {"key": "amlModuleId", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword aml_module_id: Required.
+        :paramtype aml_module_id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(ModuleProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.aml_module_id = kwargs["aml_module_id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class ModulesVersionedEntitiesResponse(msrest.serialization.Model):
+    """ModulesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.ModulesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[ModulesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.ModulesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(ModulesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class ModulesVersionedEntity(msrest.serialization.Model):
+    """ModulesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.ModuleAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.ModuleProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "ModuleAnnotations"},
+        "properties": {"key": "properties", "type": "ModuleProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.ModuleAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.ModuleProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(ModulesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class NotificationSetting(msrest.serialization.Model):
+    """NotificationSetting.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar emails: Required.
+    :vartype emails: list[str]
+    :ivar email_on: Required.
+    :vartype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem]
+    :ivar webhooks: Required. Dictionary of :code:`<Webhook>`.
+    :vartype webhooks: dict[str, ~index_service_apis.models.Webhook]
+    """
+
+    _validation = {
+        "emails": {"required": True},
+        "email_on": {"required": True},
+        "webhooks": {"required": True},
+    }
+
+    _attribute_map = {
+        "emails": {"key": "emails", "type": "[str]"},
+        "email_on": {"key": "emailOn", "type": "[str]"},
+        "webhooks": {"key": "webhooks", "type": "{Webhook}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword emails: Required.
+        :paramtype emails: list[str]
+        :keyword email_on: Required.
+        :paramtype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem]
+        :keyword webhooks: Required. Dictionary of :code:`<Webhook>`.
+        :paramtype webhooks: dict[str, ~index_service_apis.models.Webhook]
+        """
+        super(NotificationSetting, self).__init__(**kwargs)
+        self.emails = kwargs["emails"]
+        self.email_on = kwargs["email_on"]
+        self.webhooks = kwargs["webhooks"]
+
+
+class OnlineEndpointAnnotations(msrest.serialization.Model):
+    """OnlineEndpointAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar compute_type: Required.
+    :vartype compute_type: str
+    :ivar compute_target: Required.
+    :vartype compute_target: ~index_service_apis.models.EndpointComputeTarget
+    :ivar scoring_uri: Required.
+    :vartype scoring_uri: str
+    :ivar location: Required.
+    :vartype location: str
+    :ivar last_modified_time: Required.
+    :vartype last_modified_time: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "compute_type": {"required": True},
+        "compute_target": {"required": True},
+        "scoring_uri": {"required": True},
+        "location": {"required": True},
+        "last_modified_time": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "compute_type": {"key": "computeType", "type": "str"},
+        "compute_target": {"key": "computeTarget", "type": "EndpointComputeTarget"},
+        "scoring_uri": {"key": "scoringUri", "type": "str"},
+        "location": {"key": "location", "type": "str"},
+        "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword compute_type: Required.
+        :paramtype compute_type: str
+        :keyword compute_target: Required.
+        :paramtype compute_target: ~index_service_apis.models.EndpointComputeTarget
+        :keyword scoring_uri: Required.
+        :paramtype scoring_uri: str
+        :keyword location: Required.
+        :paramtype location: str
+        :keyword last_modified_time: Required.
+        :paramtype last_modified_time: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(OnlineEndpointAnnotations, self).__init__(**kwargs)
+        self.compute_type = kwargs["compute_type"]
+        self.compute_target = kwargs["compute_target"]
+        self.scoring_uri = kwargs["scoring_uri"]
+        self.location = kwargs["location"]
+        self.last_modified_time = kwargs["last_modified_time"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class OnlineEndpointProperties(msrest.serialization.Model):
+    """OnlineEndpointProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "properties": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "properties": {"key": "properties", "type": "{str}"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(OnlineEndpointProperties, self).__init__(**kwargs)
+        self.properties = kwargs["properties"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class OnlineendpointsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """OnlineendpointsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[OnlineendpointsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(OnlineendpointsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class OnlineendpointsUnversionedEntity(msrest.serialization.Model):
+    """OnlineendpointsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.OnlineEndpointAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.OnlineEndpointProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "OnlineEndpointAnnotations"},
+        "properties": {"key": "properties", "type": "OnlineEndpointProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.OnlineEndpointAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.OnlineEndpointProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(OnlineendpointsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class OutputNameAndDataTypeId(msrest.serialization.Model):
+    """OutputNameAndDataTypeId.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar data_type_id: Required.
+    :vartype data_type_id: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar label: Required.
+    :vartype label: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "data_type_id": {"required": True},
+        "description": {"required": True},
+        "label": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "data_type_id": {"key": "dataTypeId", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "label": {"key": "label", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword data_type_id: Required.
+        :paramtype data_type_id: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword label: Required.
+        :paramtype label: str
+        """
+        super(OutputNameAndDataTypeId, self).__init__(**kwargs)
+        self.name = kwargs["name"]
+        self.data_type_id = kwargs["data_type_id"]
+        self.description = kwargs["description"]
+        self.label = kwargs["label"]
+
+
+class PipelineAnnotations(msrest.serialization.Model):
+    """PipelineAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar pipeline_name: Required.
+    :vartype pipeline_name: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar url: Required.
+    :vartype url: str
+    :ivar pipeline_endpoint_ids: Required.
+    :vartype pipeline_endpoint_ids: list[str]
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar last_run_id: Required.
+    :vartype last_run_id: str
+    :ivar pipeline_type: Required.
+    :vartype pipeline_type: str
+    :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+     "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+    :vartype last_run_status_code: str or
+     ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode
+    :ivar last_run_creation_time: Required.
+    :vartype last_run_creation_time: ~datetime.datetime
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "pipeline_name": {"required": True},
+        "version": {"required": True},
+        "url": {"required": True},
+        "pipeline_endpoint_ids": {"required": True},
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "last_run_id": {"required": True},
+        "pipeline_type": {"required": True},
+        "last_run_status_code": {"required": True},
+        "last_run_creation_time": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "pipeline_name": {"key": "pipelineName", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "url": {"key": "url", "type": "str"},
+        "pipeline_endpoint_ids": {"key": "pipelineEndpointIds", "type": "[str]"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "last_run_id": {"key": "lastRunId", "type": "str"},
+        "pipeline_type": {"key": "pipelineType", "type": "str"},
+        "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"},
+        "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword pipeline_name: Required.
+        :paramtype pipeline_name: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword url: Required.
+        :paramtype url: str
+        :keyword pipeline_endpoint_ids: Required.
+        :paramtype pipeline_endpoint_ids: list[str]
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword last_run_id: Required.
+        :paramtype last_run_id: str
+        :keyword pipeline_type: Required.
+        :paramtype pipeline_type: str
+        :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+         "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+        :paramtype last_run_status_code: str or
+         ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode
+        :keyword last_run_creation_time: Required.
+        :paramtype last_run_creation_time: ~datetime.datetime
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(PipelineAnnotations, self).__init__(**kwargs)
+        self.pipeline_name = kwargs["pipeline_name"]
+        self.version = kwargs["version"]
+        self.url = kwargs["url"]
+        self.pipeline_endpoint_ids = kwargs["pipeline_endpoint_ids"]
+        self.kv_tags = kwargs["kv_tags"]
+        self.step_tags = kwargs["step_tags"]
+        self.properties = kwargs["properties"]
+        self.step_properties = kwargs["step_properties"]
+        self.entity_status = kwargs["entity_status"]
+        self.last_modified_date = kwargs["last_modified_date"]
+        self.last_updated_by = kwargs["last_updated_by"]
+        self.last_run_id = kwargs["last_run_id"]
+        self.pipeline_type = kwargs["pipeline_type"]
+        self.last_run_status_code = kwargs["last_run_status_code"]
+        self.last_run_creation_time = kwargs["last_run_creation_time"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class PipelineDraftAnnotations(msrest.serialization.Model):
+    """PipelineDraftAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar pipeline_type: Required.
+    :vartype pipeline_type: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "pipeline_type": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "pipeline_type": {"key": "pipelineType", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or
+         ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword pipeline_type: Required.
+        :paramtype pipeline_type: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(PipelineDraftAnnotations, self).__init__(**kwargs)
+        self.kv_tags = kwargs["kv_tags"]
+        self.step_tags = kwargs["step_tags"]
+        self.properties = kwargs["properties"]
+        self.step_properties = kwargs["step_properties"]
+        self.entity_status = kwargs["entity_status"]
+        self.last_modified_date = kwargs["last_modified_date"]
+        self.pipeline_type = kwargs["pipeline_type"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class PipelineDraftProperties(msrest.serialization.Model):
+    """PipelineDraftProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(PipelineDraftProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class PipelinedraftsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """PipelinedraftsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[PipelinedraftsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(PipelinedraftsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class PipelinedraftsUnversionedEntity(msrest.serialization.Model):
+    """PipelinedraftsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.PipelineDraftAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.PipelineDraftProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "PipelineDraftAnnotations"},
+        "properties": {"key": "properties", "type": "PipelineDraftProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.PipelineDraftAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.PipelineDraftProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(PipelinedraftsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class PipelineProperties(msrest.serialization.Model):
+    """PipelineProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(PipelineProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class PipelineRunAnnotations(msrest.serialization.Model):
+    """PipelineRunAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus
+    :ivar status: Required.
+    :vartype status: ~index_service_apis.models.ExperimentStatus
+    :ivar run_history_experiment_name: Required.
+    :vartype run_history_experiment_name: str
+    :ivar has_errors: Required.
+    :vartype has_errors: bool
+    :ivar has_warnings: Required.
+    :vartype has_warnings: bool
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "status": {"required": True},
+        "run_history_experiment_name": {"required": True},
+        "has_errors": {"required": True},
+        "has_warnings": {"required": True},
+        "last_modified_date": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "status": {"key": "status", "type": "ExperimentStatus"},
+        "run_history_experiment_name": {"key": "runHistoryExperimentName", "type": "str"},
+        "has_errors": {"key": "hasErrors", "type": "bool"},
+        "has_warnings": {"key": "hasWarnings", "type": "bool"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus
+        :keyword status: Required.
+        :paramtype status: ~index_service_apis.models.ExperimentStatus
+        :keyword run_history_experiment_name: Required.
+        :paramtype run_history_experiment_name: str
+        :keyword has_errors: Required.
+        :paramtype has_errors: bool
+        :keyword has_warnings: Required.
+        :paramtype has_warnings: bool
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(PipelineRunAnnotations, self).__init__(**kwargs)
+        self.kv_tags = kwargs["kv_tags"]
+        self.step_tags = kwargs["step_tags"]
+        self.properties = kwargs["properties"]
+        self.step_properties = kwargs["step_properties"]
+        self.entity_status = kwargs["entity_status"]
+        self.status = kwargs["status"]
+        self.run_history_experiment_name = kwargs["run_history_experiment_name"]
+        self.has_errors = kwargs["has_errors"]
+        self.has_warnings = kwargs["has_warnings"]
+        self.last_modified_date = kwargs["last_modified_date"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class PipelineRunProperties(msrest.serialization.Model):
+    """PipelineRunProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(PipelineRunProperties, self).__init__(**kwargs)
+        self.id = kwargs["id"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class PipelinerunsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """PipelinerunsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[PipelinerunsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(PipelinerunsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class PipelinerunsUnversionedEntity(msrest.serialization.Model):
+    """PipelinerunsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.PipelineRunAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.PipelineRunProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "PipelineRunAnnotations"},
+        "properties": {"key": "properties", "type": "PipelineRunProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.PipelineRunAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.PipelineRunProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        """
+        super(PipelinerunsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.relationships = kwargs["relationships"]
+
+
+class PipelinesVersionedEntitiesResponse(msrest.serialization.Model):
+    """PipelinesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.PipelinesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[PipelinesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.PipelinesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(PipelinesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class PipelinesVersionedEntity(msrest.serialization.Model):
+    """PipelinesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.PipelineAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.PipelineProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "PipelineAnnotations"},
+        "properties": {"key": "properties", "type": "PipelineProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.PipelineAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.PipelineProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(PipelinesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class Purpose(msrest.serialization.Model):
+    """Purpose.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar has_inferencing_support: Required.
+    :vartype has_inferencing_support: bool
+    :ivar has_training_support: Required.
+    :vartype has_training_support: bool
+    """
+
+    _validation = {
+        "has_inferencing_support": {"required": True},
+        "has_training_support": {"required": True},
+    }
+
+    _attribute_map = {
+        "has_inferencing_support": {"key": "hasInferencingSupport", "type": "bool"},
+        "has_training_support": {"key": "hasTrainingSupport", "type": "bool"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword has_inferencing_support: Required.
+        :paramtype has_inferencing_support: bool
+        :keyword has_training_support: Required.
+        :paramtype has_training_support: bool
+        """
+        super(Purpose, self).__init__(**kwargs)
+        self.has_inferencing_support = kwargs["has_inferencing_support"]
+        self.has_training_support = kwargs["has_training_support"]
+
+
+class Recurrence(msrest.serialization.Model):
+    """Recurrence.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar frequency: Required. Possible values include: "Month", "Week", "Day", "Hour", "Minute".
+    :vartype frequency: str or ~index_service_apis.models.RecurrenceFrequency
+    :ivar interval: Required.
+    :vartype interval: int
+    :ivar schedule: Required.
+    :vartype schedule: ~index_service_apis.models.RecurrenceSchedule
+    :ivar end_time: Required.
+    :vartype end_time: str
+    :ivar start_time: Required.
+    :vartype start_time: str
+    :ivar time_zone: Required.
+    :vartype time_zone: str
+    """
+
+    _validation = {
+        "frequency": {"required": True},
+        "interval": {"required": True},
+        "schedule": {"required": True},
+        "end_time": {"required": True},
+        "start_time": {"required": True},
+        "time_zone": {"required": True},
+    }
+
+    _attribute_map = {
+        "frequency": {"key": "frequency", "type": "str"},
+        "interval": {"key": "interval", "type": "int"},
+        "schedule": {"key": "schedule", "type": "RecurrenceSchedule"},
+        "end_time": {"key": "endTime", "type": "str"},
+        "start_time": {"key": "startTime", "type": "str"},
+        "time_zone": {"key": "timeZone", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword frequency: Required. Possible values include: "Month", "Week", "Day", "Hour",
+         "Minute".
+        :paramtype frequency: str or ~index_service_apis.models.RecurrenceFrequency
+        :keyword interval: Required.
+        :paramtype interval: int
+        :keyword schedule: Required.
+        :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule
+        :keyword end_time: Required.
+        :paramtype end_time: str
+        :keyword start_time: Required.
+        :paramtype start_time: str
+        :keyword time_zone: Required.
+        :paramtype time_zone: str
+        """
+        super(Recurrence, self).__init__(**kwargs)
+        self.frequency = kwargs["frequency"]
+        self.interval = kwargs["interval"]
+        self.schedule = kwargs["schedule"]
+        self.end_time = kwargs["end_time"]
+        self.start_time = kwargs["start_time"]
+        self.time_zone = kwargs["time_zone"]
+
+
+class RecurrenceSchedule(msrest.serialization.Model):
+    """RecurrenceSchedule.
+
+    :ivar hours:
+    :vartype hours: list[int]
+    :ivar minutes:
+    :vartype minutes: list[int]
+    :ivar week_days:
+    :vartype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem]
+    :ivar month_days:
+    :vartype month_days: list[int]
+    """
+
+    _attribute_map = {
+        "hours": {"key": "hours", "type": "[int]"},
+        "minutes": {"key": "minutes", "type": "[int]"},
+        "week_days": {"key": "weekDays", "type": "[str]"},
+        "month_days": {"key": "monthDays", "type": "[int]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword hours:
+        :paramtype hours: list[int]
+        :keyword minutes:
+        :paramtype minutes: list[int]
+        :keyword week_days:
+        :paramtype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem]
+        :keyword month_days:
+        :paramtype month_days: list[int]
+        """
+        super(RecurrenceSchedule, self).__init__(**kwargs)
+        self.hours = kwargs.get("hours", None)
+        self.minutes = kwargs.get("minutes", None)
+        self.week_days = kwargs.get("week_days", None)
+        self.month_days = kwargs.get("month_days", None)
+
+
+class RecurrenceTrigger(msrest.serialization.Model):
+    """RecurrenceTrigger.
+
+    :ivar frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute".
+    :vartype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency
+    :ivar interval:
+    :vartype interval: int
+    :ivar schedule:
+    :vartype schedule: ~index_service_apis.models.RecurrenceSchedule
+    """
+
+    _attribute_map = {
+        "frequency": {"key": "frequency", "type": "str"},
+        "interval": {"key": "interval", "type": "int"},
+        "schedule": {"key": "schedule", "type": "RecurrenceSchedule"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute".
+        :paramtype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency
+        :keyword interval:
+        :paramtype interval: int
+        :keyword schedule:
+        :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule
+        """
+        super(RecurrenceTrigger, self).__init__(**kwargs)
+        self.frequency = kwargs.get("frequency", None)
+        self.interval = kwargs.get("interval", None)
+        self.schedule = kwargs.get("schedule", None)
+
+
+class Relationship(msrest.serialization.Model):
+    """Relationship.
+
+    Variables are only populated by the server, and will be ignored when sending a request.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar relation_type:
+    :vartype relation_type: str
+    :ivar target_entity_id:
+    :vartype target_entity_id: str
+    :ivar asset_id:
+    :vartype asset_id: str
+    :ivar entity_type:
+    :vartype entity_type: str
+    :ivar direction:
+    :vartype direction: str
+    :ivar entity_container_id:
+    :vartype entity_container_id: str
+    """
+
+    _validation = {
+        "entity_type": {"readonly": True},
+        "entity_container_id": {"readonly": True},
+    }
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "relation_type": {"key": "relationType", "type": "str"},
+        "target_entity_id": {"key": "targetEntityId", "type": "str"},
+        "asset_id": {"key": "assetId", "type": "str"},
+        "entity_type": {"key": "entityType", "type": "str"},
+        "direction": {"key": "direction", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword relation_type:
+        :paramtype relation_type: str
+        :keyword target_entity_id:
+        :paramtype target_entity_id: str
+        :keyword asset_id:
+        :paramtype asset_id: str
+        :keyword direction:
+        :paramtype direction: str
+        """
+        super(Relationship, self).__init__(**kwargs)
+        self.additional_properties = kwargs.get("additional_properties", None)
+        self.relation_type = kwargs.get("relation_type", None)
+        self.target_entity_id = kwargs.get("target_entity_id", None)
+        self.asset_id = kwargs.get("asset_id", None)
+        self.entity_type = None
+        self.direction = kwargs.get("direction", None)
+        self.entity_container_id = None
+
+
+class ResourceDiscoveryContainerMetadata(msrest.serialization.Model):
+    """ResourceDiscoveryContainerMetadata.
+
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    :ivar tenant_id:
+    :vartype tenant_id: str
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar resource_arm_id:
+    :vartype resource_arm_id: str
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group:
+    :vartype resource_group: str
+    :ivar resource_name:
+    :vartype resource_name: str
+    :ivar asset_container_type:
+    :vartype asset_container_type: str
+    :ivar immutable_resource_id:
+    :vartype immutable_resource_id: str
+    :ivar asset_resource_type:
+    :vartype asset_resource_type: str
+    :ivar is_customer_managed_resource:
+    :vartype is_customer_managed_resource: bool
+    :ivar is_private_link_behind_vnet:
+    :vartype is_private_link_behind_vnet: bool
+    :ivar is_public_container:
+    :vartype is_public_container: bool
+    :ivar is_public_resource:
+    :vartype is_public_resource: bool
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    """
+
+    _attribute_map = {
+        "tags": {"key": "tags", "type": "{str}"},
+        "tenant_id": {"key": "tenantId", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "resource_arm_id": {"key": "resourceArmId", "type": "str"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group": {"key": "resourceGroup", "type": "str"},
+        "resource_name": {"key": "resourceName", "type": "str"},
+        "asset_container_type": {"key": "assetContainerType", "type": "str"},
+        "immutable_resource_id": {"key": "immutableResourceId", "type": "str"},
+        "asset_resource_type": {"key": "assetResourceType", "type": "str"},
+        "is_customer_managed_resource": {"key": "isCustomerManagedResource", "type": "bool"},
+        "is_private_link_behind_vnet": {"key": "isPrivateLinkBehindVnet", "type": "bool"},
+        "is_public_container": {"key": "isPublicContainer", "type": "bool"},
+        "is_public_resource": {"key": "isPublicResource", "type": "bool"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        :keyword tenant_id:
+        :paramtype tenant_id: str
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword resource_arm_id:
+        :paramtype resource_arm_id: str
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group:
+        :paramtype resource_group: str
+        :keyword resource_name:
+        :paramtype resource_name: str
+        :keyword asset_container_type:
+        :paramtype asset_container_type: str
+        :keyword immutable_resource_id:
+        :paramtype immutable_resource_id: str
+        :keyword asset_resource_type:
+        :paramtype asset_resource_type: str
+        :keyword is_customer_managed_resource:
+        :paramtype is_customer_managed_resource: bool
+        :keyword is_private_link_behind_vnet:
+        :paramtype is_private_link_behind_vnet: bool
+        :keyword is_public_container:
+        :paramtype is_public_container: bool
+        :keyword is_public_resource:
+        :paramtype is_public_resource: bool
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        """
+        super(ResourceDiscoveryContainerMetadata, self).__init__(**kwargs)
+        self.tags = kwargs.get("tags", None)
+        self.tenant_id = kwargs.get("tenant_id", None)
+        self.resource_id = kwargs.get("resource_id", None)
+        self.resource_arm_id = kwargs.get("resource_arm_id", None)
+        self.subscription_id = kwargs.get("subscription_id", None)
+        self.resource_group = kwargs.get("resource_group", None)
+        self.resource_name = kwargs.get("resource_name", None)
+        self.asset_container_type = kwargs.get("asset_container_type", None)
+        self.immutable_resource_id = kwargs.get("immutable_resource_id", None)
+        self.asset_resource_type = kwargs.get("asset_resource_type", None)
+        self.is_customer_managed_resource = kwargs.get("is_customer_managed_resource", None)
+        self.is_private_link_behind_vnet = kwargs.get("is_private_link_behind_vnet", None)
+        self.is_public_container = kwargs.get("is_public_container", None)
+        self.is_public_resource = kwargs.get("is_public_resource", None)
+        self.regions = kwargs.get("regions", None)
+
+
+class ResourceDiscoveryContainerMetadataPaginatedResult(msrest.serialization.Model):
+    """ResourceDiscoveryContainerMetadataPaginatedResult.
+
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata]
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar next_link:
+    :vartype next_link: str
+    """
+
+    _attribute_map = {
+        "value": {"key": "value", "type": "[ResourceDiscoveryContainerMetadata]"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "next_link": {"key": "nextLink", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata]
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword next_link:
+        :paramtype next_link: str
+        """
+        super(ResourceDiscoveryContainerMetadataPaginatedResult, self).__init__(**kwargs)
+        self.value = kwargs.get("value", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.next_link = kwargs.get("next_link", None)
+
+
+class ResourceDiscoveryRequest(msrest.serialization.Model):
+    """ResourceDiscoveryRequest.
+
+    :ivar search_request:
+    :vartype search_request: ~index_service_apis.models.StringContainsRequest
+    :ivar order_by:
+    :vartype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder
+    :ivar filters:
+    :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar page_size:
+    :vartype page_size: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    """
+
+    _attribute_map = {
+        "search_request": {"key": "searchRequest", "type": "StringContainsRequest"},
+        "order_by": {"key": "orderBy", "type": "IndexEntitiesRequestOrder"},
+        "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"},
+        "page_size": {"key": "pageSize", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword search_request:
+        :paramtype search_request: ~index_service_apis.models.StringContainsRequest
+        :keyword order_by:
+        :paramtype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder
+        :keyword filters:
+        :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword page_size:
+        :paramtype page_size: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        """
+        super(ResourceDiscoveryRequest, self).__init__(**kwargs)
+        self.search_request = kwargs.get("search_request", None)
+        self.order_by = kwargs.get("order_by", None)
+        self.filters = kwargs.get("filters", None)
+        self.page_size = kwargs.get("page_size", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+
+
+class ResourceInformation(msrest.serialization.Model):
+    """ResourceInformation.
+
+    :ivar region:
+    :vartype region: str
+    :ivar entity_container_type: Possible values include: "Workspace", "Feed", "Registry".
+    :vartype entity_container_type: str or ~index_service_apis.models.AssetContainerTypeFeedRename
+    :ivar resource_id:
+    :vartype resource_id: str
+    """
+
+    _attribute_map = {
+        "region": {"key": "region", "type": "str"},
+        "entity_container_type": {"key": "entityContainerType", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword region:
+        :paramtype region: str
+        :keyword entity_container_type: Possible values include: "Workspace", "Feed", "Registry".
+        :paramtype entity_container_type: str or
+         ~index_service_apis.models.AssetContainerTypeFeedRename
+        :keyword resource_id:
+        :paramtype resource_id: str
+        """
+        super(ResourceInformation, self).__init__(**kwargs)
+        self.region = kwargs.get("region", None)
+        self.entity_container_type = kwargs.get("entity_container_type", None)
+        self.resource_id = kwargs.get("resource_id", None)
+
+
+class ResourceRegion(msrest.serialization.Model):
+    """ResourceRegion.
+
+    :ivar region_name:
+    :vartype region_name: str
+    :ivar is_primary_region:
+    :vartype is_primary_region: bool
+    """
+
+    _attribute_map = {
+        "region_name": {"key": "regionName", "type": "str"},
+        "is_primary_region": {"key": "isPrimaryRegion", "type": "bool"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword region_name:
+        :paramtype region_name: str
+        :keyword is_primary_region:
+        :paramtype is_primary_region: bool
+        """
+        super(ResourceRegion, self).__init__(**kwargs)
+        self.region_name = kwargs.get("region_name", None)
+        self.is_primary_region = kwargs.get("is_primary_region", None)
+
+
+class RootError(msrest.serialization.Model):
+    """RootError.
+
+    :ivar code:
+    :vartype code: str
+    :ivar severity:
+    :vartype severity: int
+    :ivar message:
+    :vartype message: str
+    :ivar message_format:
+    :vartype message_format: str
+    :ivar message_parameters: Dictionary of :code:`<string>`.
+    :vartype message_parameters: dict[str, str]
+    :ivar reference_code:
+    :vartype reference_code: str
+    :ivar details_uri:
+    :vartype details_uri: str
+    :ivar target:
+    :vartype target: str
+    :ivar details:
+    :vartype details: list[~index_service_apis.models.RootError]
+    :ivar inner_error:
+    :vartype inner_error: ~index_service_apis.models.InnerErrorResponse
+    :ivar debug_info:
+    :vartype debug_info: ~index_service_apis.models.DebugInfoResponse
+    :ivar additional_info:
+    :vartype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo]
+    """
+
+    _attribute_map = {
+        "code": {"key": "code", "type": "str"},
+        "severity": {"key": "severity", "type": "int"},
+        "message": {"key": "message", "type": "str"},
+        "message_format": {"key": "messageFormat", "type": "str"},
+        "message_parameters": {"key": "messageParameters", "type": "{str}"},
+        "reference_code": {"key": "referenceCode", "type": "str"},
+        "details_uri": {"key": "detailsUri", "type": "str"},
+        "target": {"key": "target", "type": "str"},
+        "details": {"key": "details", "type": "[RootError]"},
+        "inner_error": {"key": "innerError", "type": "InnerErrorResponse"},
+        "debug_info": {"key": "debugInfo", "type": "DebugInfoResponse"},
+        "additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword code:
+        :paramtype code: str
+        :keyword severity:
+        :paramtype severity: int
+        :keyword message:
+        :paramtype message: str
+        :keyword message_format:
+        :paramtype message_format: str
+        :keyword message_parameters: Dictionary of :code:`<string>`.
+        :paramtype message_parameters: dict[str, str]
+        :keyword reference_code:
+        :paramtype reference_code: str
+        :keyword details_uri:
+        :paramtype details_uri: str
+        :keyword target:
+        :paramtype target: str
+        :keyword details:
+        :paramtype details: list[~index_service_apis.models.RootError]
+        :keyword inner_error:
+        :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse
+        :keyword debug_info:
+        :paramtype debug_info: ~index_service_apis.models.DebugInfoResponse
+        :keyword additional_info:
+        :paramtype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo]
+        """
+        super(RootError, self).__init__(**kwargs)
+        self.code = kwargs.get("code", None)
+        self.severity = kwargs.get("severity", None)
+        self.message = kwargs.get("message", None)
+        self.message_format = kwargs.get("message_format", None)
+        self.message_parameters = kwargs.get("message_parameters", None)
+        self.reference_code = kwargs.get("reference_code", None)
+        self.details_uri = kwargs.get("details_uri", None)
+        self.target = kwargs.get("target", None)
+        self.details = kwargs.get("details", None)
+        self.inner_error = kwargs.get("inner_error", None)
+        self.debug_info = kwargs.get("debug_info", None)
+        self.additional_info = kwargs.get("additional_info", None)
+
+
+class RunAnnotations(msrest.serialization.Model):
+    """RunAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar display_name: Required.
+    :vartype display_name: str
+    :ivar status: Required.
+    :vartype status: str
+    :ivar primary_metric_name: Required.
+    :vartype primary_metric_name: str
+    :ivar estimated_cost: Required.
+    :vartype estimated_cost: float
+    :ivar primary_metric_summary: Required.
+    :vartype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue
+    :ivar metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>.
+    :vartype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject]
+    :ivar parameters: Required. Dictionary of :code:`<AnyObject>`.
+    :vartype parameters: dict[str, any]
+    :ivar settings: Required. Dictionary of :code:`<string>`.
+    :vartype settings: dict[str, str]
+    :ivar modified_time: Required.
+    :vartype modified_time: ~datetime.datetime
+    :ivar retain_for_lifetime_of_workspace: Required.
+    :vartype retain_for_lifetime_of_workspace: bool
+    :ivar error: Required.
+    :vartype error: ~index_service_apis.models.IndexedErrorResponse
+    :ivar resource_metric_summary: Required.
+    :vartype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary
+    :ivar job_cost: Required.
+    :vartype job_cost: ~index_service_apis.models.JobCost
+    :ivar compute_duration: Required.
+    :vartype compute_duration: str
+    :ivar compute_duration_milliseconds: Required.
+    :vartype compute_duration_milliseconds: float
+    :ivar effective_start_time_utc: Required.
+    :vartype effective_start_time_utc: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "display_name": {"required": True},
+        "status": {"required": True},
+        "primary_metric_name": {"required": True},
+        "estimated_cost": {"required": True},
+        "primary_metric_summary": {"required": True},
+        "metrics": {"required": True},
+        "parameters": {"required": True},
+        "settings": {"required": True},
+        "modified_time": {"required": True},
+        "retain_for_lifetime_of_workspace": {"required": True},
+        "error": {"required": True},
+        "resource_metric_summary": {"required": True},
+        "job_cost": {"required": True},
+        "compute_duration": {"required": True},
+        "compute_duration_milliseconds": {"required": True},
+        "effective_start_time_utc": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "display_name": {"key": "displayName", "type": "str"},
+        "status": {"key": "status", "type": "str"},
+        "primary_metric_name": {"key": "primaryMetricName", "type": "str"},
+        "estimated_cost": {"key": "estimatedCost", "type": "float"},
+        "primary_metric_summary": {"key": "primaryMetricSummary", "type": "RunIndexMetricSummaryJValue"},
+        "metrics": {"key": "metrics", "type": "{RunIndexMetricSummaryObject}"},
+        "parameters": {"key": "parameters", "type": "{object}"},
+        "settings": {"key": "settings", "type": "{str}"},
+        "modified_time": {"key": "modifiedTime", "type": "iso-8601"},
+        "retain_for_lifetime_of_workspace": {"key": "retainForLifetimeOfWorkspace", "type": "bool"},
+        "error": {"key": "error", "type": "IndexedErrorResponse"},
+        "resource_metric_summary": {"key": "resourceMetricSummary", "type": "RunIndexResourceMetricSummary"},
+        "job_cost": {"key": "jobCost", "type": "JobCost"},
+        "compute_duration": {"key": "computeDuration", "type": "str"},
+        "compute_duration_milliseconds": {"key": "computeDurationMilliseconds", "type": "float"},
+        "effective_start_time_utc": {"key": "effectiveStartTimeUtc", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword display_name: Required.
+        :paramtype display_name: str
+        :keyword status: Required.
+        :paramtype status: str
+        :keyword primary_metric_name: Required.
+        :paramtype primary_metric_name: str
+        :keyword estimated_cost: Required.
+        :paramtype estimated_cost: float
+        :keyword primary_metric_summary: Required.
+        :paramtype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue
+        :keyword metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>.
+        :paramtype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject]
+        :keyword parameters: Required. Dictionary of :code:`<AnyObject>`.
+        :paramtype parameters: dict[str, any]
+        :keyword settings: Required. Dictionary of :code:`<string>`.
+        :paramtype settings: dict[str, str]
+        :keyword modified_time: Required.
+        :paramtype modified_time: ~datetime.datetime
+        :keyword retain_for_lifetime_of_workspace: Required.
+        :paramtype retain_for_lifetime_of_workspace: bool
+        :keyword error: Required.
+        :paramtype error: ~index_service_apis.models.IndexedErrorResponse
+        :keyword resource_metric_summary: Required.
+        :paramtype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary
+        :keyword job_cost: Required.
+        :paramtype job_cost: ~index_service_apis.models.JobCost
+        :keyword compute_duration: Required.
+        :paramtype compute_duration: str
+        :keyword compute_duration_milliseconds: Required.
+        :paramtype compute_duration_milliseconds: float
+        :keyword effective_start_time_utc: Required.
+        :paramtype effective_start_time_utc: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(RunAnnotations, self).__init__(**kwargs)
+        self.display_name = kwargs["display_name"]
+        self.status = kwargs["status"]
+        self.primary_metric_name = kwargs["primary_metric_name"]
+        self.estimated_cost = kwargs["estimated_cost"]
+        self.primary_metric_summary = kwargs["primary_metric_summary"]
+        self.metrics = kwargs["metrics"]
+        self.parameters = kwargs["parameters"]
+        self.settings = kwargs["settings"]
+        self.modified_time = kwargs["modified_time"]
+        self.retain_for_lifetime_of_workspace = kwargs["retain_for_lifetime_of_workspace"]
+        self.error = kwargs["error"]
+        self.resource_metric_summary = kwargs["resource_metric_summary"]
+        self.job_cost = kwargs["job_cost"]
+        self.compute_duration = kwargs["compute_duration"]
+        self.compute_duration_milliseconds = kwargs["compute_duration_milliseconds"]
+        self.effective_start_time_utc = kwargs["effective_start_time_utc"]
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.archived = kwargs["archived"]
+        self.tags = kwargs["tags"]
+
+
+class RunIndexMetricSummaryJValue(msrest.serialization.Model):
+    """RunIndexMetricSummaryJValue.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar count: Required.
+    :vartype count: int
+    :ivar last_value: Required. Any object.
+    :vartype last_value: any
+    :ivar minimum_value: Required. Any object.
+    :vartype minimum_value: any
+    :ivar maximum_value: Required. Any object.
+    :vartype maximum_value: any
+    :ivar metric_type: Required.
+    :vartype metric_type: str
+    """
+
+    _validation = {
+        "count": {"required": True},
+        "last_value": {"required": True},
+        "minimum_value": {"required": True},
+        "maximum_value": {"required": True},
+        "metric_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "count": {"key": "count", "type": "int"},
+        "last_value": {"key": "lastValue", "type": "object"},
+        "minimum_value": {"key": "minimumValue", "type": "object"},
+        "maximum_value": {"key": "maximumValue", "type": "object"},
+        "metric_type": {"key": "metricType", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword count: Required.
+        :paramtype count: int
+        :keyword last_value: Required. Any object.
+        :paramtype last_value: any
+        :keyword minimum_value: Required. Any object.
+        :paramtype minimum_value: any
+        :keyword maximum_value: Required. Any object.
+        :paramtype maximum_value: any
+        :keyword metric_type: Required.
+        :paramtype metric_type: str
+        """
+        super(RunIndexMetricSummaryJValue, self).__init__(**kwargs)
+        self.count = kwargs["count"]
+        self.last_value = kwargs["last_value"]
+        self.minimum_value = kwargs["minimum_value"]
+        self.maximum_value = kwargs["maximum_value"]
+        self.metric_type = kwargs["metric_type"]
+
+
+class RunIndexMetricSummaryObject(msrest.serialization.Model):
+    """RunIndexMetricSummaryObject.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar count: Required.
+    :vartype count: int
+    :ivar last_value: Required. Anything.
+    :vartype last_value: any
+    :ivar minimum_value: Required. Anything.
+    :vartype minimum_value: any
+    :ivar maximum_value: Required. Anything.
+    :vartype maximum_value: any
+    :ivar metric_type: Required.
+    :vartype metric_type: str
+    """
+
+    _validation = {
+        "count": {"required": True},
+        "last_value": {"required": True},
+        "minimum_value": {"required": True},
+        "maximum_value": {"required": True},
+        "metric_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "count": {"key": "count", "type": "int"},
+        "last_value": {"key": "lastValue", "type": "object"},
+        "minimum_value": {"key": "minimumValue", "type": "object"},
+        "maximum_value": {"key": "maximumValue", "type": "object"},
+        "metric_type": {"key": "metricType", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword count: Required.
+        :paramtype count: int
+        :keyword last_value: Required. Anything.
+        :paramtype last_value: any
+        :keyword minimum_value: Required. Anything.
+        :paramtype minimum_value: any
+        :keyword maximum_value: Required. Anything.
+        :paramtype maximum_value: any
+        :keyword metric_type: Required.
+        :paramtype metric_type: str
+        """
+        super(RunIndexMetricSummaryObject, self).__init__(**kwargs)
+        self.count = kwargs["count"]
+        self.last_value = kwargs["last_value"]
+        self.minimum_value = kwargs["minimum_value"]
+        self.maximum_value = kwargs["maximum_value"]
+        self.metric_type = kwargs["metric_type"]
+
+
+class RunIndexResourceMetricSummary(msrest.serialization.Model):
+    """RunIndexResourceMetricSummary.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar gpu_utilization_percent_last_hour: Required.
+    :vartype gpu_utilization_percent_last_hour: float
+    :ivar gpu_memory_utilization_percent_last_hour: Required.
+    :vartype gpu_memory_utilization_percent_last_hour: float
+    :ivar gpu_energy_joules: Required.
+    :vartype gpu_energy_joules: float
+    :ivar resource_metric_names: Required.
+    :vartype resource_metric_names: list[str]
+    """
+
+    _validation = {
+        "gpu_utilization_percent_last_hour": {"required": True},
+        "gpu_memory_utilization_percent_last_hour": {"required": True},
+        "gpu_energy_joules": {"required": True},
+        "resource_metric_names": {"required": True},
+    }
+
+    _attribute_map = {
+        "gpu_utilization_percent_last_hour": {"key": "gpuUtilizationPercentLastHour", "type": "float"},
+        "gpu_memory_utilization_percent_last_hour": {"key": "gpuMemoryUtilizationPercentLastHour", "type": "float"},
+        "gpu_energy_joules": {"key": "gpuEnergyJoules", "type": "float"},
+        "resource_metric_names": {"key": "resourceMetricNames", "type": "[str]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword gpu_utilization_percent_last_hour: Required.
+        :paramtype gpu_utilization_percent_last_hour: float
+        :keyword gpu_memory_utilization_percent_last_hour: Required.
+        :paramtype gpu_memory_utilization_percent_last_hour: float
+        :keyword gpu_energy_joules: Required.
+        :paramtype gpu_energy_joules: float
+        :keyword resource_metric_names: Required.
+        :paramtype resource_metric_names: list[str]
+        """
+        super(RunIndexResourceMetricSummary, self).__init__(**kwargs)
+        self.gpu_utilization_percent_last_hour = kwargs["gpu_utilization_percent_last_hour"]
+        self.gpu_memory_utilization_percent_last_hour = kwargs["gpu_memory_utilization_percent_last_hour"]
+        self.gpu_energy_joules = kwargs["gpu_energy_joules"]
+        self.resource_metric_names = kwargs["resource_metric_names"]
+
+
+class RunProperties(msrest.serialization.Model):
+    """RunProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar data_container_id: Required.
+    :vartype data_container_id: str
+    :ivar target_name: Required.
+    :vartype target_name: str
+    :ivar run_name: Required.
+    :vartype run_name: str
+    :ivar experiment_name: Required.
+    :vartype experiment_name: str
+    :ivar run_id: Required.
+    :vartype run_id: str
+    :ivar parent_run_id: Required.
+    :vartype parent_run_id: str
+    :ivar root_run_id: Required.
+    :vartype root_run_id: str
+    :ivar run_type: Required.
+    :vartype run_type: str
+    :ivar run_type_v2: Required.
+    :vartype run_type_v2: ~index_service_apis.models.RunTypeV2Index
+    :ivar script_name: Required.
+    :vartype script_name: str
+    :ivar experiment_id: Required.
+    :vartype experiment_id: str
+    :ivar run_uuid: Required.
+    :vartype run_uuid: str
+    :ivar parent_run_uuid: Required.
+    :vartype parent_run_uuid: str
+    :ivar run_number: Required.
+    :vartype run_number: int
+    :ivar start_time: Required.
+    :vartype start_time: ~datetime.datetime
+    :ivar end_time: Required.
+    :vartype end_time: ~datetime.datetime
+    :ivar compute_request: Required.
+    :vartype compute_request: ~index_service_apis.models.ComputeRequest
+    :ivar compute: Required.
+    :vartype compute: ~index_service_apis.models.Compute
+    :ivar user_properties: Required. Dictionary of :code:`<string>`.
+    :vartype user_properties: dict[str, str]
+    :ivar action_uris: Required. Dictionary of :code:`<string>`.
+    :vartype action_uris: dict[str, str]
+    :ivar duration: Required.
+    :vartype duration: str
+    :ivar duration_milliseconds: Required.
+    :vartype duration_milliseconds: float
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "data_container_id": {"required": True},
+        "target_name": {"required": True},
+        "run_name": {"required": True},
+        "experiment_name": {"required": True},
+        "run_id": {"required": True},
+        "parent_run_id": {"required": True},
+        "root_run_id": {"required": True},
+        "run_type": {"required": True},
+        "run_type_v2": {"required": True},
+        "script_name": {"required": True},
+        "experiment_id": {"required": True},
+        "run_uuid": {"required": True},
+        "parent_run_uuid": {"required": True},
+        "run_number": {"required": True},
+        "start_time": {"required": True},
+        "end_time": {"required": True},
+        "compute_request": {"required": True},
+        "compute": {"required": True},
+        "user_properties": {"required": True},
+        "action_uris": {"required": True},
+        "duration": {"required": True},
+        "duration_milliseconds": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "data_container_id": {"key": "dataContainerId", "type": "str"},
+        "target_name": {"key": "targetName", "type": "str"},
+        "run_name": {"key": "runName", "type": "str"},
+        "experiment_name": {"key": "experimentName", "type": "str"},
+        "run_id": {"key": "runId", "type": "str"},
+        "parent_run_id": {"key": "parentRunId", "type": "str"},
+        "root_run_id": {"key": "rootRunId", "type": "str"},
+        "run_type": {"key": "runType", "type": "str"},
+        "run_type_v2": {"key": "runTypeV2", "type": "RunTypeV2Index"},
+        "script_name": {"key": "scriptName", "type": "str"},
+        "experiment_id": {"key": "experimentId", "type": "str"},
+        "run_uuid": {"key": "runUuid", "type": "str"},
+        "parent_run_uuid": {"key": "parentRunUuid", "type": "str"},
+        "run_number": {"key": "runNumber", "type": "int"},
+        "start_time": {"key": "startTime", "type": "iso-8601"},
+        "end_time": {"key": "endTime", "type": "iso-8601"},
+        "compute_request": {"key": "computeRequest", "type": "ComputeRequest"},
+        "compute": {"key": "compute", "type": "Compute"},
+        "user_properties": {"key": "userProperties", "type": "{str}"},
+        "action_uris": {"key": "actionUris", "type": "{str}"},
+        "duration": {"key": "duration", "type": "str"},
+        "duration_milliseconds": {"key": "durationMilliseconds", "type": "float"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword data_container_id: Required.
+        :paramtype data_container_id: str
+        :keyword target_name: Required.
+        :paramtype target_name: str
+        :keyword run_name: Required.
+        :paramtype run_name: str
+        :keyword experiment_name: Required.
+        :paramtype experiment_name: str
+        :keyword run_id: Required.
+        :paramtype run_id: str
+        :keyword parent_run_id: Required.
+        :paramtype parent_run_id: str
+        :keyword root_run_id: Required.
+        :paramtype root_run_id: str
+        :keyword run_type: Required.
+        :paramtype run_type: str
+        :keyword run_type_v2: Required.
+        :paramtype run_type_v2: ~index_service_apis.models.RunTypeV2Index
+        :keyword script_name: Required.
+        :paramtype script_name: str
+        :keyword experiment_id: Required.
+        :paramtype experiment_id: str
+        :keyword run_uuid: Required.
+        :paramtype run_uuid: str
+        :keyword parent_run_uuid: Required.
+        :paramtype parent_run_uuid: str
+        :keyword run_number: Required.
+        :paramtype run_number: int
+        :keyword start_time: Required.
+        :paramtype start_time: ~datetime.datetime
+        :keyword end_time: Required.
+        :paramtype end_time: ~datetime.datetime
+        :keyword compute_request: Required.
+        :paramtype compute_request: ~index_service_apis.models.ComputeRequest
+        :keyword compute: Required.
+        :paramtype compute: ~index_service_apis.models.Compute
+        :keyword user_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype user_properties: dict[str, str]
+        :keyword action_uris: Required. Dictionary of :code:`<string>`.
+        :paramtype action_uris: dict[str, str]
+        :keyword duration: Required.
+        :paramtype duration: str
+        :keyword duration_milliseconds: Required.
+        :paramtype duration_milliseconds: float
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(RunProperties, self).__init__(**kwargs)
+        self.data_container_id = kwargs["data_container_id"]
+        self.target_name = kwargs["target_name"]
+        self.run_name = kwargs["run_name"]
+        self.experiment_name = kwargs["experiment_name"]
+        self.run_id = kwargs["run_id"]
+        self.parent_run_id = kwargs["parent_run_id"]
+        self.root_run_id = kwargs["root_run_id"]
+        self.run_type = kwargs["run_type"]
+        self.run_type_v2 = kwargs["run_type_v2"]
+        self.script_name = kwargs["script_name"]
+        self.experiment_id = kwargs["experiment_id"]
+        self.run_uuid = kwargs["run_uuid"]
+        self.parent_run_uuid = kwargs["parent_run_uuid"]
+        self.run_number = kwargs["run_number"]
+        self.start_time = kwargs["start_time"]
+        self.end_time = kwargs["end_time"]
+        self.compute_request = kwargs["compute_request"]
+        self.compute = kwargs["compute"]
+        self.user_properties = kwargs["user_properties"]
+        self.action_uris = kwargs["action_uris"]
+        self.duration = kwargs["duration"]
+        self.duration_milliseconds = kwargs["duration_milliseconds"]
+        self.creation_context = kwargs["creation_context"]
+
+
+class RunsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """RunsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.RunsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[RunsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.RunsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(RunsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+        self.value = kwargs.get("value", None)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.continuation_token = kwargs.get("continuation_token", None)
+        self.entity_container_ids_to_entity_container_metadata = kwargs.get(
+            "entity_container_ids_to_entity_container_metadata", None
+        )
+        self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None)
+        self.fanout_data = kwargs.get("fanout_data", None)
+        self.shard_errors = kwargs.get("shard_errors", None)
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get(
+            "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None
+        )
+
+
+class RunsUnversionedEntity(msrest.serialization.Model):
+    """RunsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.RunAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.RunProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "RunAnnotations"},
+        "properties": {"key": "properties", "type": "RunProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.RunAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.RunProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(RunsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = kwargs["schema_id"]
+        self.entity_id = kwargs["entity_id"]
+        self.kind = kwargs["kind"]
+        self.annotations = kwargs["annotations"]
+        self.properties = kwargs["properties"]
+        self.internal = kwargs["internal"]
+        self.update_sequence = kwargs["update_sequence"]
+        self.type = kwargs["type"]
+        self.version = kwargs["version"]
+        self.entity_container_id = kwargs["entity_container_id"]
+        self.entity_object_id = kwargs["entity_object_id"]
+        self.resource_type = kwargs["resource_type"]
+        self.relationships = kwargs["relationships"]
+        self.asset_id = kwargs.get("asset_id", None)
+
+
+class RunTypeV2Index(msrest.serialization.Model):
+    """RunTypeV2Index.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar orchestrator: Required.
+    :vartype orchestrator: str
+    :ivar traits: Required. Dictionary of :code:`<string>`.
+    :vartype traits: dict[str, str]
+    :ivar attribution: Required.
+    :vartype attribution: str
+    :ivar compute_type: Required.
+    :vartype compute_type: str
+    """
+
+    _validation = {
+        "orchestrator": {"required": True},
+        "traits": {"required": True},
+        "attribution": {"required": True},
+        "compute_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "orchestrator": {"key": "orchestrator", "type": "str"},
+        "traits": {"key": "traits", "type": "{str}"},
+        "attribution": {"key": "attribution", "type": "str"},
+        "compute_type": {"key": "computeType", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword orchestrator: Required.
+        :paramtype orchestrator: str
+        :keyword traits: Required. Dictionary of :code:`<string>`.
+        :paramtype traits: dict[str, str]
+        :keyword attribution: Required.
+        :paramtype attribution: str
+        :keyword compute_type: Required.
+        :paramtype compute_type: str
+        """
+        super(RunTypeV2Index, self).__init__(**kwargs)
+        self.orchestrator = kwargs["orchestrator"]
+        self.traits = kwargs["traits"]
+        self.attribution = kwargs["attribution"]
+        self.compute_type = kwargs["compute_type"]
+
+
+class SingleShardFanoutData(msrest.serialization.Model):
+    """SingleShardFanoutData.
+
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar is_shard_done:
+    :vartype is_shard_done: bool
+    :ivar did_shard_fail:
+    :vartype did_shard_fail: bool
+    :ivar total_count:
+    :vartype total_count: long
+    """
+
+    _attribute_map = {
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "is_shard_done": {"key": "isShardDone", "type": "bool"},
+        "did_shard_fail": {"key": "didShardFail", "type": "bool"},
+        "total_count": {"key": "totalCount", "type": "long"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword is_shard_done:
+        :paramtype is_shard_done: bool
+        :keyword did_shard_fail:
+        :paramtype did_shard_fail: bool
+        :keyword total_count:
+        :paramtype total_count: long
+        """
+        super(SingleShardFanoutData, self).__init__(**kwargs)
+        self.next_skip = kwargs.get("next_skip", None)
+        self.is_shard_done = kwargs.get("is_shard_done", None)
+        self.did_shard_fail = kwargs.get("did_shard_fail", None)
+        self.total_count = kwargs.get("total_count", None)
+
+
+class StringContainsRequest(msrest.serialization.Model):
+    """StringContainsRequest.
+
+    :ivar value_to_check:
+    :vartype value_to_check: str
+    :ivar columns_to_check:
+    :vartype columns_to_check: list[str]
+    """
+
+    _attribute_map = {
+        "value_to_check": {"key": "valueToCheck", "type": "str"},
+        "columns_to_check": {"key": "columnsToCheck", "type": "[str]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword value_to_check:
+        :paramtype value_to_check: str
+        :keyword columns_to_check:
+        :paramtype columns_to_check: list[str]
+        """
+        super(StringContainsRequest, self).__init__(**kwargs)
+        self.value_to_check = kwargs.get("value_to_check", None)
+        self.columns_to_check = kwargs.get("columns_to_check", None)
+
+
+class StructuredInterfaceParameter(msrest.serialization.Model):
+    """StructuredInterfaceParameter.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar label: Required.
+    :vartype label: str
+    :ivar parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String",
+     "Undefined".
+    :vartype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType
+    :ivar is_optional: Required.
+    :vartype is_optional: bool
+    :ivar default_value: Required.
+    :vartype default_value: str
+    :ivar lower_bound: Required.
+    :vartype lower_bound: str
+    :ivar upper_bound: Required.
+    :vartype upper_bound: str
+    :ivar enum_values: Required.
+    :vartype enum_values: list[str]
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "description": {"required": True},
+        "label": {"required": True},
+        "parameter_type": {"required": True},
+        "is_optional": {"required": True},
+        "default_value": {"required": True},
+        "lower_bound": {"required": True},
+        "upper_bound": {"required": True},
+        "enum_values": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "label": {"key": "label", "type": "str"},
+        "parameter_type": {"key": "parameterType", "type": "str"},
+        "is_optional": {"key": "isOptional", "type": "bool"},
+        "default_value": {"key": "defaultValue", "type": "str"},
+        "lower_bound": {"key": "lowerBound", "type": "str"},
+        "upper_bound": {"key": "upperBound", "type": "str"},
+        "enum_values": {"key": "enumValues", "type": "[str]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword label: Required.
+        :paramtype label: str
+        :keyword parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String",
+         "Undefined".
+        :paramtype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType
+        :keyword is_optional: Required.
+        :paramtype is_optional: bool
+        :keyword default_value: Required.
+        :paramtype default_value: str
+        :keyword lower_bound: Required.
+        :paramtype lower_bound: str
+        :keyword upper_bound: Required.
+        :paramtype upper_bound: str
+        :keyword enum_values: Required.
+        :paramtype enum_values: list[str]
+        """
+        super(StructuredInterfaceParameter, self).__init__(**kwargs)
+        self.name = kwargs["name"]
+        self.description = kwargs["description"]
+        self.label = kwargs["label"]
+        self.parameter_type = kwargs["parameter_type"]
+        self.is_optional = kwargs["is_optional"]
+        self.default_value = kwargs["default_value"]
+        self.lower_bound = kwargs["lower_bound"]
+        self.upper_bound = kwargs["upper_bound"]
+        self.enum_values = kwargs["enum_values"]
+
+
+class TimeDeltaDto(msrest.serialization.Model):
+    """TimeDeltaDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar days: Required.
+    :vartype days: int
+    :ivar hours: Required.
+    :vartype hours: int
+    :ivar minutes: Required.
+    :vartype minutes: int
+    """
+
+    _validation = {
+        "days": {"required": True},
+        "hours": {"required": True},
+        "minutes": {"required": True},
+    }
+
+    _attribute_map = {
+        "days": {"key": "days", "type": "int"},
+        "hours": {"key": "hours", "type": "int"},
+        "minutes": {"key": "minutes", "type": "int"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword days: Required.
+        :paramtype days: int
+        :keyword hours: Required.
+        :paramtype hours: int
+        :keyword minutes: Required.
+        :paramtype minutes: int
+        """
+        super(TimeDeltaDto, self).__init__(**kwargs)
+        self.days = kwargs["days"]
+        self.hours = kwargs["hours"]
+        self.minutes = kwargs["minutes"]
+
+
+class TimestampColumnDto(msrest.serialization.Model):
+    """TimestampColumnDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar format: Required.
+    :vartype format: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "format": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "format": {"key": "format", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword format: Required.
+        :paramtype format: str
+        """
+        super(TimestampColumnDto, self).__init__(**kwargs)
+        self.name = kwargs["name"]
+        self.format = kwargs["format"]
+
+
+class UnqueriableResourcesScope(msrest.serialization.Model):
+    """UnqueriableResourcesScope.
+
+    :ivar resource_set:
+    :vartype resource_set: list[~index_service_apis.models.ResourceInformation]
+    """
+
+    _attribute_map = {
+        "resource_set": {"key": "resourceSet", "type": "[ResourceInformation]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword resource_set:
+        :paramtype resource_set: list[~index_service_apis.models.ResourceInformation]
+        """
+        super(UnqueriableResourcesScope, self).__init__(**kwargs)
+        self.resource_set = kwargs.get("resource_set", None)
+
+
+class Usage(msrest.serialization.Model):
+    """Usage.
+
+    :ivar total_count:
+    :vartype total_count: long
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        """
+        super(Usage, self).__init__(**kwargs)
+        self.total_count = kwargs.get("total_count", None)
+
+
+class UserDto(msrest.serialization.Model):
+    """UserDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar user_object_id: Required.
+    :vartype user_object_id: str
+    :ivar user_tenant_id: Required.
+    :vartype user_tenant_id: str
+    :ivar user_name: Required.
+    :vartype user_name: str
+    """
+
+    _validation = {
+        "user_object_id": {"required": True},
+        "user_tenant_id": {"required": True},
+        "user_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_name": {"key": "userName", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword user_object_id: Required.
+        :paramtype user_object_id: str
+        :keyword user_tenant_id: Required.
+        :paramtype user_tenant_id: str
+        :keyword user_name: Required.
+        :paramtype user_name: str
+        """
+        super(UserDto, self).__init__(**kwargs)
+        self.user_object_id = kwargs["user_object_id"]
+        self.user_tenant_id = kwargs["user_tenant_id"]
+        self.user_name = kwargs["user_name"]
+
+
+class UxPresenceResource(msrest.serialization.Model):
+    """UxPresenceResource.
+
+    :ivar name:
+    :vartype name: str
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar resource_type:
+    :vartype resource_type: str
+    :ivar region:
+    :vartype region: str
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group_name:
+    :vartype resource_group_name: str
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    :ivar is_customer_managed:
+    :vartype is_customer_managed: bool
+    :ivar is_private_link_resource:
+    :vartype is_private_link_resource: bool
+    :ivar is_private_link_resource_behind_vnet:
+    :vartype is_private_link_resource_behind_vnet: bool
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "region": {"key": "region", "type": "str"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group_name": {"key": "resourceGroupName", "type": "str"},
+        "tags": {"key": "tags", "type": "{str}"},
+        "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"},
+        "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"},
+        "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name:
+        :paramtype name: str
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword resource_type:
+        :paramtype resource_type: str
+        :keyword region:
+        :paramtype region: str
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group_name:
+        :paramtype resource_group_name: str
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        :keyword is_customer_managed:
+        :paramtype is_customer_managed: bool
+        :keyword is_private_link_resource:
+        :paramtype is_private_link_resource: bool
+        :keyword is_private_link_resource_behind_vnet:
+        :paramtype is_private_link_resource_behind_vnet: bool
+        """
+        super(UxPresenceResource, self).__init__(**kwargs)
+        self.name = kwargs.get("name", None)
+        self.resource_id = kwargs.get("resource_id", None)
+        self.resource_type = kwargs.get("resource_type", None)
+        self.region = kwargs.get("region", None)
+        self.regions = kwargs.get("regions", None)
+        self.subscription_id = kwargs.get("subscription_id", None)
+        self.resource_group_name = kwargs.get("resource_group_name", None)
+        self.tags = kwargs.get("tags", None)
+        self.is_customer_managed = kwargs.get("is_customer_managed", None)
+        self.is_private_link_resource = kwargs.get("is_private_link_resource", None)
+        self.is_private_link_resource_behind_vnet = kwargs.get("is_private_link_resource_behind_vnet", None)
+
+
+class UxWarmUpRequest(msrest.serialization.Model):
+    """UxWarmUpRequest.
+
+    :ivar entity_types:
+    :vartype entity_types: list[str]
+    :ivar resource_ids:
+    :vartype resource_ids: list[str]
+    """
+
+    _attribute_map = {
+        "entity_types": {"key": "entityTypes", "type": "[str]"},
+        "resource_ids": {"key": "resourceIds", "type": "[str]"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword entity_types:
+        :paramtype entity_types: list[str]
+        :keyword resource_ids:
+        :paramtype resource_ids: list[str]
+        """
+        super(UxWarmUpRequest, self).__init__(**kwargs)
+        self.entity_types = kwargs.get("entity_types", None)
+        self.resource_ids = kwargs.get("resource_ids", None)
+
+
+class VersionedAttribute(msrest.serialization.Model):
+    """VersionedAttribute.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar version: Required.
+    :vartype version: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "version": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword version: Required.
+        :paramtype version: str
+        """
+        super(VersionedAttribute, self).__init__(**kwargs)
+        self.name = kwargs["name"]
+        self.version = kwargs["version"]
+
+
+class Webhook(msrest.serialization.Model):
+    """Webhook.
+
+    Variables are only populated by the server, and will be ignored when sending a request.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar webhook_type:  Has constant value: "AzureDevOps".
+    :vartype webhook_type: str
+    :ivar event_type: Required.
+    :vartype event_type: str
+    """
+
+    _validation = {
+        "webhook_type": {"required": True, "constant": True},
+        "event_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "webhook_type": {"key": "webhookType", "type": "str"},
+        "event_type": {"key": "eventType", "type": "str"},
+    }
+
+    webhook_type = "AzureDevOps"
+
+    def __init__(self, **kwargs):
+        """
+        :keyword event_type: Required.
+        :paramtype event_type: str
+        """
+        super(Webhook, self).__init__(**kwargs)
+        self.event_type = kwargs["event_type"]
+
+
+class WorkspaceContextWarmUpRequest(msrest.serialization.Model):
+    """WorkspaceContextWarmUpRequest.
+
+    :ivar discover_registries:
+    :vartype discover_registries: bool
+    """
+
+    _attribute_map = {
+        "discover_registries": {"key": "discoverRegistries", "type": "bool"},
+    }
+
+    def __init__(self, **kwargs):
+        """
+        :keyword discover_registries:
+        :paramtype discover_registries: bool
+        """
+        super(WorkspaceContextWarmUpRequest, self).__init__(**kwargs)
+        self.discover_registries = kwargs.get("discover_registries", None)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models_py3.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models_py3.py
new file mode 100644
index 00000000..515cd873
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models_py3.py
@@ -0,0 +1,10478 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import msrest.serialization
+
+from ._index_service_apis_enums import *
+
+
+class BatchEndpointAnnotations(msrest.serialization.Model):
+    """BatchEndpointAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar scoring_uri: Required.
+    :vartype scoring_uri: str
+    :ivar location: Required.
+    :vartype location: str
+    :ivar last_modified_time: Required.
+    :vartype last_modified_time: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "scoring_uri": {"required": True},
+        "location": {"required": True},
+        "last_modified_time": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "scoring_uri": {"key": "scoringUri", "type": "str"},
+        "location": {"key": "location", "type": "str"},
+        "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        scoring_uri: str,
+        location: str,
+        last_modified_time: datetime.datetime,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword scoring_uri: Required.
+        :paramtype scoring_uri: str
+        :keyword location: Required.
+        :paramtype location: str
+        :keyword last_modified_time: Required.
+        :paramtype last_modified_time: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(BatchEndpointAnnotations, self).__init__(**kwargs)
+        self.scoring_uri = scoring_uri
+        self.location = location
+        self.last_modified_time = last_modified_time
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class BatchEndpointProperties(msrest.serialization.Model):
+    """BatchEndpointProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "properties": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "properties": {"key": "properties", "type": "{str}"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, properties: Dict[str, str], creation_context: "CreationContext", **kwargs):
+        """
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(BatchEndpointProperties, self).__init__(**kwargs)
+        self.properties = properties
+        self.creation_context = creation_context
+
+
+class BatchendpointsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """BatchendpointsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[BatchendpointsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["BatchendpointsUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(BatchendpointsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class BatchendpointsUnversionedEntity(msrest.serialization.Model):
+    """BatchendpointsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.BatchEndpointAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.BatchEndpointProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "BatchEndpointAnnotations"},
+        "properties": {"key": "properties", "type": "BatchEndpointProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "BatchendpointsUnversionedEntityKind"],
+        annotations: "BatchEndpointAnnotations",
+        properties: "BatchEndpointProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.BatchEndpointAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.BatchEndpointProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(BatchendpointsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class Compute(msrest.serialization.Model):
+    """Compute.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar target: Required.
+    :vartype target: str
+    :ivar target_type: Required.
+    :vartype target_type: str
+    :ivar vm_size: Required.
+    :vartype vm_size: str
+    :ivar instance_type: Required.
+    :vartype instance_type: str
+    :ivar instance_count: Required.
+    :vartype instance_count: int
+    :ivar gpu_count: Required.
+    :vartype gpu_count: int
+    :ivar priority: Required.
+    :vartype priority: str
+    :ivar region: Required.
+    :vartype region: str
+    :ivar arm_id: Required.
+    :vartype arm_id: str
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    """
+
+    _validation = {
+        "target": {"required": True},
+        "target_type": {"required": True},
+        "vm_size": {"required": True},
+        "instance_type": {"required": True},
+        "instance_count": {"required": True},
+        "gpu_count": {"required": True},
+        "priority": {"required": True},
+        "region": {"required": True},
+        "arm_id": {"required": True},
+        "properties": {"required": True},
+    }
+
+    _attribute_map = {
+        "target": {"key": "target", "type": "str"},
+        "target_type": {"key": "targetType", "type": "str"},
+        "vm_size": {"key": "vmSize", "type": "str"},
+        "instance_type": {"key": "instanceType", "type": "str"},
+        "instance_count": {"key": "instanceCount", "type": "int"},
+        "gpu_count": {"key": "gpuCount", "type": "int"},
+        "priority": {"key": "priority", "type": "str"},
+        "region": {"key": "region", "type": "str"},
+        "arm_id": {"key": "armId", "type": "str"},
+        "properties": {"key": "properties", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        target: str,
+        target_type: str,
+        vm_size: str,
+        instance_type: str,
+        instance_count: int,
+        gpu_count: int,
+        priority: str,
+        region: str,
+        arm_id: str,
+        properties: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword target: Required.
+        :paramtype target: str
+        :keyword target_type: Required.
+        :paramtype target_type: str
+        :keyword vm_size: Required.
+        :paramtype vm_size: str
+        :keyword instance_type: Required.
+        :paramtype instance_type: str
+        :keyword instance_count: Required.
+        :paramtype instance_count: int
+        :keyword gpu_count: Required.
+        :paramtype gpu_count: int
+        :keyword priority: Required.
+        :paramtype priority: str
+        :keyword region: Required.
+        :paramtype region: str
+        :keyword arm_id: Required.
+        :paramtype arm_id: str
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        """
+        super(Compute, self).__init__(**kwargs)
+        self.target = target
+        self.target_type = target_type
+        self.vm_size = vm_size
+        self.instance_type = instance_type
+        self.instance_count = instance_count
+        self.gpu_count = gpu_count
+        self.priority = priority
+        self.region = region
+        self.arm_id = arm_id
+        self.properties = properties
+
+
+class ComputeRequest(msrest.serialization.Model):
+    """ComputeRequest.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar node_count: Required.
+    :vartype node_count: int
+    :ivar gpu_count: Required.
+    :vartype gpu_count: int
+    """
+
+    _validation = {
+        "node_count": {"required": True},
+        "gpu_count": {"required": True},
+    }
+
+    _attribute_map = {
+        "node_count": {"key": "nodeCount", "type": "int"},
+        "gpu_count": {"key": "gpuCount", "type": "int"},
+    }
+
+    def __init__(self, *, node_count: int, gpu_count: int, **kwargs):
+        """
+        :keyword node_count: Required.
+        :paramtype node_count: int
+        :keyword gpu_count: Required.
+        :paramtype gpu_count: int
+        """
+        super(ComputeRequest, self).__init__(**kwargs)
+        self.node_count = node_count
+        self.gpu_count = gpu_count
+
+
+class ContainerResourceRequirements(msrest.serialization.Model):
+    """ContainerResourceRequirements.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar cpu: Required.
+    :vartype cpu: float
+    :ivar cpu_limit: Required.
+    :vartype cpu_limit: float
+    :ivar memory_in_gb: Required.
+    :vartype memory_in_gb: float
+    :ivar memory_in_gb_limit: Required.
+    :vartype memory_in_gb_limit: float
+    :ivar gpu_enabled: Required.
+    :vartype gpu_enabled: bool
+    :ivar gpu: Required.
+    :vartype gpu: int
+    :ivar fpga: Required.
+    :vartype fpga: int
+    """
+
+    _validation = {
+        "cpu": {"required": True},
+        "cpu_limit": {"required": True},
+        "memory_in_gb": {"required": True},
+        "memory_in_gb_limit": {"required": True},
+        "gpu_enabled": {"required": True},
+        "gpu": {"required": True},
+        "fpga": {"required": True},
+    }
+
+    _attribute_map = {
+        "cpu": {"key": "cpu", "type": "float"},
+        "cpu_limit": {"key": "cpuLimit", "type": "float"},
+        "memory_in_gb": {"key": "memoryInGB", "type": "float"},
+        "memory_in_gb_limit": {"key": "memoryInGBLimit", "type": "float"},
+        "gpu_enabled": {"key": "gpuEnabled", "type": "bool"},
+        "gpu": {"key": "gpu", "type": "int"},
+        "fpga": {"key": "fpga", "type": "int"},
+    }
+
+    def __init__(
+        self,
+        *,
+        cpu: float,
+        cpu_limit: float,
+        memory_in_gb: float,
+        memory_in_gb_limit: float,
+        gpu_enabled: bool,
+        gpu: int,
+        fpga: int,
+        **kwargs
+    ):
+        """
+        :keyword cpu: Required.
+        :paramtype cpu: float
+        :keyword cpu_limit: Required.
+        :paramtype cpu_limit: float
+        :keyword memory_in_gb: Required.
+        :paramtype memory_in_gb: float
+        :keyword memory_in_gb_limit: Required.
+        :paramtype memory_in_gb_limit: float
+        :keyword gpu_enabled: Required.
+        :paramtype gpu_enabled: bool
+        :keyword gpu: Required.
+        :paramtype gpu: int
+        :keyword fpga: Required.
+        :paramtype fpga: int
+        """
+        super(ContainerResourceRequirements, self).__init__(**kwargs)
+        self.cpu = cpu
+        self.cpu_limit = cpu_limit
+        self.memory_in_gb = memory_in_gb
+        self.memory_in_gb_limit = memory_in_gb_limit
+        self.gpu_enabled = gpu_enabled
+        self.gpu = gpu
+        self.fpga = fpga
+
+
+class ControlOutput(msrest.serialization.Model):
+    """ControlOutput.
+
+    :ivar name:
+    :vartype name: str
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+    }
+
+    def __init__(self, *, name: Optional[str] = None, **kwargs):
+        """
+        :keyword name:
+        :paramtype name: str
+        """
+        super(ControlOutput, self).__init__(**kwargs)
+        self.name = name
+
+
+class CreatedBy(msrest.serialization.Model):
+    """CreatedBy.
+
+    :ivar user_object_id:
+    :vartype user_object_id: str
+    :ivar user_tenant_id:
+    :vartype user_tenant_id: str
+    :ivar user_name:
+    :vartype user_name: str
+    """
+
+    _attribute_map = {
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_name": {"key": "userName", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        user_object_id: Optional[str] = None,
+        user_tenant_id: Optional[str] = None,
+        user_name: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword user_object_id:
+        :paramtype user_object_id: str
+        :keyword user_tenant_id:
+        :paramtype user_tenant_id: str
+        :keyword user_name:
+        :paramtype user_name: str
+        """
+        super(CreatedBy, self).__init__(**kwargs)
+        self.user_object_id = user_object_id
+        self.user_tenant_id = user_tenant_id
+        self.user_name = user_name
+
+
+class CreatedBy1(msrest.serialization.Model):
+    """CreatedBy1.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar user_object_id: Required.
+    :vartype user_object_id: str
+    :ivar user_tenant_id: Required.
+    :vartype user_tenant_id: str
+    :ivar user_name: Required.
+    :vartype user_name: str
+    """
+
+    _validation = {
+        "user_object_id": {"required": True},
+        "user_tenant_id": {"required": True},
+        "user_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_name": {"key": "userName", "type": "str"},
+    }
+
+    def __init__(self, *, user_object_id: str, user_tenant_id: str, user_name: str, **kwargs):
+        """
+        :keyword user_object_id: Required.
+        :paramtype user_object_id: str
+        :keyword user_tenant_id: Required.
+        :paramtype user_tenant_id: str
+        :keyword user_name: Required.
+        :paramtype user_name: str
+        """
+        super(CreatedBy1, self).__init__(**kwargs)
+        self.user_object_id = user_object_id
+        self.user_tenant_id = user_tenant_id
+        self.user_name = user_name
+
+
+class CreationContext(msrest.serialization.Model):
+    """CreationContext.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar created_time:
+    :vartype created_time: ~datetime.datetime
+    :ivar created_by:
+    :vartype created_by: ~index_service_apis.models.CreatedBy
+    :ivar creation_source:
+    :vartype creation_source: str
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "created_time": {"key": "createdTime", "type": "iso-8601"},
+        "created_by": {"key": "createdBy", "type": "CreatedBy"},
+        "creation_source": {"key": "creationSource", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        additional_properties: Optional[Dict[str, Any]] = None,
+        created_time: Optional[datetime.datetime] = None,
+        created_by: Optional["CreatedBy"] = None,
+        creation_source: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword created_time:
+        :paramtype created_time: ~datetime.datetime
+        :keyword created_by:
+        :paramtype created_by: ~index_service_apis.models.CreatedBy
+        :keyword creation_source:
+        :paramtype creation_source: str
+        """
+        super(CreationContext, self).__init__(**kwargs)
+        self.additional_properties = additional_properties
+        self.created_time = created_time
+        self.created_by = created_by
+        self.creation_source = creation_source
+
+
+class CronTrigger(msrest.serialization.Model):
+    """CronTrigger.
+
+    :ivar expression:
+    :vartype expression: str
+    """
+
+    _attribute_map = {
+        "expression": {"key": "expression", "type": "str"},
+    }
+
+    def __init__(self, *, expression: Optional[str] = None, **kwargs):
+        """
+        :keyword expression:
+        :paramtype expression: str
+        """
+        super(CronTrigger, self).__init__(**kwargs)
+        self.expression = expression
+
+
+class CrossRegionIndexEntitiesRequest(msrest.serialization.Model):
+    """CrossRegionIndexEntitiesRequest.
+
+    :ivar resource_ids:
+    :vartype resource_ids: list[~index_service_apis.models.ResourceInformation]
+    :ivar index_entities_request:
+    :vartype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest
+    """
+
+    _attribute_map = {
+        "resource_ids": {"key": "resourceIds", "type": "[ResourceInformation]"},
+        "index_entities_request": {"key": "indexEntitiesRequest", "type": "IndexEntitiesRequest"},
+    }
+
+    def __init__(
+        self,
+        *,
+        resource_ids: Optional[List["ResourceInformation"]] = None,
+        index_entities_request: Optional["IndexEntitiesRequest"] = None,
+        **kwargs
+    ):
+        """
+        :keyword resource_ids:
+        :paramtype resource_ids: list[~index_service_apis.models.ResourceInformation]
+        :keyword index_entities_request:
+        :paramtype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest
+        """
+        super(CrossRegionIndexEntitiesRequest, self).__init__(**kwargs)
+        self.resource_ids = resource_ids
+        self.index_entities_request = index_entities_request
+
+
+class CrossRegionIndexEntitiesResponse(msrest.serialization.Model):
+    """CrossRegionIndexEntitiesResponse.
+
+    :ivar index_entities_response:
+    :vartype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse
+    :ivar regional_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar shard_errors: Dictionary of
+     <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>.
+    :vartype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]]
+    :ivar number_of_resources_not_included_in_search:
+    :vartype number_of_resources_not_included_in_search: int
+    """
+
+    _attribute_map = {
+        "index_entities_response": {"key": "indexEntitiesResponse", "type": "IndexEntitiesResponse"},
+        "regional_errors": {"key": "regionalErrors", "type": "{ErrorResponse}"},
+        "shard_errors": {"key": "shardErrors", "type": "{{ErrorResponse}}"},
+        "number_of_resources_not_included_in_search": {"key": "numberOfResourcesNotIncludedInSearch", "type": "int"},
+    }
+
+    def __init__(
+        self,
+        *,
+        index_entities_response: Optional["IndexEntitiesResponse"] = None,
+        regional_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        shard_errors: Optional[Dict[str, Dict[str, "ErrorResponse"]]] = None,
+        number_of_resources_not_included_in_search: Optional[int] = None,
+        **kwargs
+    ):
+        """
+        :keyword index_entities_response:
+        :paramtype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse
+        :keyword regional_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword shard_errors: Dictionary of
+         <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>.
+        :paramtype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]]
+        :keyword number_of_resources_not_included_in_search:
+        :paramtype number_of_resources_not_included_in_search: int
+        """
+        super(CrossRegionIndexEntitiesResponse, self).__init__(**kwargs)
+        self.index_entities_response = index_entities_response
+        self.regional_errors = regional_errors
+        self.shard_errors = shard_errors
+        self.number_of_resources_not_included_in_search = number_of_resources_not_included_in_search
+
+
+class CudaAttribute(msrest.serialization.Model):
+    """CudaAttribute.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar cuda_version: Required.
+    :vartype cuda_version: str
+    :ivar cu_dnn_version: Required.
+    :vartype cu_dnn_version: str
+    :ivar nccl_version: Required.
+    :vartype nccl_version: str
+    """
+
+    _validation = {
+        "cuda_version": {"required": True},
+        "cu_dnn_version": {"required": True},
+        "nccl_version": {"required": True},
+    }
+
+    _attribute_map = {
+        "cuda_version": {"key": "cudaVersion", "type": "str"},
+        "cu_dnn_version": {"key": "cuDnnVersion", "type": "str"},
+        "nccl_version": {"key": "ncclVersion", "type": "str"},
+    }
+
+    def __init__(self, *, cuda_version: str, cu_dnn_version: str, nccl_version: str, **kwargs):
+        """
+        :keyword cuda_version: Required.
+        :paramtype cuda_version: str
+        :keyword cu_dnn_version: Required.
+        :paramtype cu_dnn_version: str
+        :keyword nccl_version: Required.
+        :paramtype nccl_version: str
+        """
+        super(CudaAttribute, self).__init__(**kwargs)
+        self.cuda_version = cuda_version
+        self.cu_dnn_version = cu_dnn_version
+        self.nccl_version = nccl_version
+
+
+class DatasetAnnotations(msrest.serialization.Model):
+    """DatasetAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar modified_time: Required.
+    :vartype modified_time: ~datetime.datetime
+    :ivar modified_by: Required.
+    :vartype modified_by: ~index_service_apis.models.UserDto
+    :ivar next_version_id: Required.
+    :vartype next_version_id: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar labels: Required. Dictionary of :code:`<string>`.
+    :vartype labels: dict[str, str]
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "modified_time": {"required": True},
+        "modified_by": {"required": True},
+        "next_version_id": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "labels": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "modified_time": {"key": "modifiedTime", "type": "iso-8601"},
+        "modified_by": {"key": "modifiedBy", "type": "UserDto"},
+        "next_version_id": {"key": "nextVersionId", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "labels": {"key": "labels", "type": "{str}"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        modified_time: datetime.datetime,
+        modified_by: "UserDto",
+        next_version_id: str,
+        name: str,
+        description: str,
+        labels: Dict[str, str],
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword modified_time: Required.
+        :paramtype modified_time: ~datetime.datetime
+        :keyword modified_by: Required.
+        :paramtype modified_by: ~index_service_apis.models.UserDto
+        :keyword next_version_id: Required.
+        :paramtype next_version_id: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword labels: Required. Dictionary of :code:`<string>`.
+        :paramtype labels: dict[str, str]
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(DatasetAnnotations, self).__init__(**kwargs)
+        self.modified_time = modified_time
+        self.modified_by = modified_by
+        self.next_version_id = next_version_id
+        self.name = name
+        self.description = description
+        self.labels = labels
+        self.archived = archived
+        self.tags = tags
+
+
+class DatasetProperties(msrest.serialization.Model):
+    """DatasetProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar subtype: Required.
+    :vartype subtype: str
+    :ivar is_registered: Required.
+    :vartype is_registered: bool
+    :ivar data_type: Required.
+    :vartype data_type: str
+    :ivar is_v2: Required.
+    :vartype is_v2: bool
+    :ivar name_lower_case: Required.
+    :vartype name_lower_case: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "subtype": {"required": True},
+        "is_registered": {"required": True},
+        "data_type": {"required": True},
+        "is_v2": {"required": True},
+        "name_lower_case": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "subtype": {"key": "subtype", "type": "str"},
+        "is_registered": {"key": "isRegistered", "type": "bool"},
+        "data_type": {"key": "dataType", "type": "str"},
+        "is_v2": {"key": "isV2", "type": "bool"},
+        "name_lower_case": {"key": "nameLowerCase", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(
+        self,
+        *,
+        subtype: str,
+        is_registered: bool,
+        data_type: str,
+        is_v2: bool,
+        name_lower_case: str,
+        creation_context: "CreationContext",
+        **kwargs
+    ):
+        """
+        :keyword subtype: Required.
+        :paramtype subtype: str
+        :keyword is_registered: Required.
+        :paramtype is_registered: bool
+        :keyword data_type: Required.
+        :paramtype data_type: str
+        :keyword is_v2: Required.
+        :paramtype is_v2: bool
+        :keyword name_lower_case: Required.
+        :paramtype name_lower_case: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(DatasetProperties, self).__init__(**kwargs)
+        self.subtype = subtype
+        self.is_registered = is_registered
+        self.data_type = data_type
+        self.is_v2 = is_v2
+        self.name_lower_case = name_lower_case
+        self.creation_context = creation_context
+
+
+class DatasetReference(msrest.serialization.Model):
+    """DatasetReference.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar id: Required.
+    :vartype id: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "id": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "id": {"key": "id", "type": "str"},
+    }
+
+    def __init__(self, *, name: str, id: str, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword id: Required.
+        :paramtype id: str
+        """
+        super(DatasetReference, self).__init__(**kwargs)
+        self.name = name
+        self.id = id
+
+
+class DatasetsVersionedEntitiesResponse(msrest.serialization.Model):
+    """DatasetsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.DatasetsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[DatasetsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["DatasetsVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.DatasetsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(DatasetsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class DatasetsVersionedEntity(msrest.serialization.Model):
+    """DatasetsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.DatasetAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.DatasetProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "DatasetAnnotations"},
+        "properties": {"key": "properties", "type": "DatasetProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "DatasetsVersionedEntityKind"],
+        annotations: "DatasetAnnotations",
+        properties: "DatasetProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.DatasetAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.DatasetProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(DatasetsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class DataStoreAnnotations(msrest.serialization.Model):
+    """DataStoreAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar data_store_type: Required. Possible values include: "AzureBlob", "AzureFile",
+     "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase",
+     "AzurePostgreSql", "DBFS", "AzureDataLakeGen2".
+    :vartype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType
+    :ivar data_store_type_name: Required.
+    :vartype data_store_type_name: str
+    :ivar storage_name: Required.
+    :vartype storage_name: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "data_store_type": {"required": True},
+        "data_store_type_name": {"required": True},
+        "storage_name": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "data_store_type": {"key": "dataStoreType", "type": "str"},
+        "data_store_type_name": {"key": "dataStoreTypeName", "type": "str"},
+        "storage_name": {"key": "storageName", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        data_store_type: Union[str, "DataStoreAnnotationsDataStoreType"],
+        data_store_type_name: str,
+        storage_name: str,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword data_store_type: Required. Possible values include: "AzureBlob", "AzureFile",
+         "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase",
+         "AzurePostgreSql", "DBFS", "AzureDataLakeGen2".
+        :paramtype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType
+        :keyword data_store_type_name: Required.
+        :paramtype data_store_type_name: str
+        :keyword storage_name: Required.
+        :paramtype storage_name: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(DataStoreAnnotations, self).__init__(**kwargs)
+        self.data_store_type = data_store_type
+        self.data_store_type_name = data_store_type_name
+        self.storage_name = storage_name
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class DataStoreProperties(msrest.serialization.Model):
+    """DataStoreProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(DataStoreProperties, self).__init__(**kwargs)
+        self.creation_context = creation_context
+
+
+class DatastoresUnversionedEntitiesResponse(msrest.serialization.Model):
+    """DatastoresUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.DatastoresUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[DatastoresUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["DatastoresUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.DatastoresUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(DatastoresUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class DatastoresUnversionedEntity(msrest.serialization.Model):
+    """DatastoresUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.DataStoreAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.DataStoreProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "DataStoreAnnotations"},
+        "properties": {"key": "properties", "type": "DataStoreProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "DatastoresUnversionedEntityKind"],
+        annotations: "DataStoreAnnotations",
+        properties: "DataStoreProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.DataStoreAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.DataStoreProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(DatastoresUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class DebugInfoResponse(msrest.serialization.Model):
+    """DebugInfoResponse.
+
+    :ivar type:
+    :vartype type: str
+    :ivar message:
+    :vartype message: str
+    :ivar stack_trace:
+    :vartype stack_trace: str
+    :ivar inner_exception:
+    :vartype inner_exception: ~index_service_apis.models.DebugInfoResponse
+    :ivar data: Dictionary of :code:`<any>`.
+    :vartype data: dict[str, any]
+    :ivar error_response:
+    :vartype error_response: ~index_service_apis.models.ErrorResponse
+    """
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "message": {"key": "message", "type": "str"},
+        "stack_trace": {"key": "stackTrace", "type": "str"},
+        "inner_exception": {"key": "innerException", "type": "DebugInfoResponse"},
+        "data": {"key": "data", "type": "{object}"},
+        "error_response": {"key": "errorResponse", "type": "ErrorResponse"},
+    }
+
+    def __init__(
+        self,
+        *,
+        type: Optional[str] = None,
+        message: Optional[str] = None,
+        stack_trace: Optional[str] = None,
+        inner_exception: Optional["DebugInfoResponse"] = None,
+        data: Optional[Dict[str, Any]] = None,
+        error_response: Optional["ErrorResponse"] = None,
+        **kwargs
+    ):
+        """
+        :keyword type:
+        :paramtype type: str
+        :keyword message:
+        :paramtype message: str
+        :keyword stack_trace:
+        :paramtype stack_trace: str
+        :keyword inner_exception:
+        :paramtype inner_exception: ~index_service_apis.models.DebugInfoResponse
+        :keyword data: Dictionary of :code:`<any>`.
+        :paramtype data: dict[str, any]
+        :keyword error_response:
+        :paramtype error_response: ~index_service_apis.models.ErrorResponse
+        """
+        super(DebugInfoResponse, self).__init__(**kwargs)
+        self.type = type
+        self.message = message
+        self.stack_trace = stack_trace
+        self.inner_exception = inner_exception
+        self.data = data
+        self.error_response = error_response
+
+
+class DefinitionAnnotations(msrest.serialization.Model):
+    """DefinitionAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(self, *, description: str, archived: bool, tags: Dict[str, str], **kwargs):
+        """
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(DefinitionAnnotations, self).__init__(**kwargs)
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class DefinitionProperties(msrest.serialization.Model):
+    """DefinitionProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar automatically_saved: Required.
+    :vartype automatically_saved: bool
+    :ivar definition_hash: Required.
+    :vartype definition_hash: str
+    :ivar environment_attributes: Required.
+    :vartype environment_attributes: ~index_service_apis.models.EnvironmentAttributes
+    :ivar stage: Required.
+    :vartype stage: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "automatically_saved": {"required": True},
+        "definition_hash": {"required": True},
+        "environment_attributes": {"required": True},
+        "stage": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "automatically_saved": {"key": "automaticallySaved", "type": "bool"},
+        "definition_hash": {"key": "definitionHash", "type": "str"},
+        "environment_attributes": {"key": "environmentAttributes", "type": "EnvironmentAttributes"},
+        "stage": {"key": "stage", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(
+        self,
+        *,
+        automatically_saved: bool,
+        definition_hash: str,
+        environment_attributes: "EnvironmentAttributes",
+        stage: str,
+        creation_context: "CreationContext",
+        **kwargs
+    ):
+        """
+        :keyword automatically_saved: Required.
+        :paramtype automatically_saved: bool
+        :keyword definition_hash: Required.
+        :paramtype definition_hash: str
+        :keyword environment_attributes: Required.
+        :paramtype environment_attributes: ~index_service_apis.models.EnvironmentAttributes
+        :keyword stage: Required.
+        :paramtype stage: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(DefinitionProperties, self).__init__(**kwargs)
+        self.automatically_saved = automatically_saved
+        self.definition_hash = definition_hash
+        self.environment_attributes = environment_attributes
+        self.stage = stage
+        self.creation_context = creation_context
+
+
+class EndpointComputeTarget(msrest.serialization.Model):
+    """EndpointComputeTarget.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar namespace: Required.
+    :vartype namespace: str
+    :ivar compute_target_name: Required.
+    :vartype compute_target_name: str
+    """
+
+    _validation = {
+        "namespace": {"required": True},
+        "compute_target_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "namespace": {"key": "namespace", "type": "str"},
+        "compute_target_name": {"key": "computeTargetName", "type": "str"},
+    }
+
+    def __init__(self, *, namespace: str, compute_target_name: str, **kwargs):
+        """
+        :keyword namespace: Required.
+        :paramtype namespace: str
+        :keyword compute_target_name: Required.
+        :paramtype compute_target_name: str
+        """
+        super(EndpointComputeTarget, self).__init__(**kwargs)
+        self.namespace = namespace
+        self.compute_target_name = compute_target_name
+
+
+class EnvironmentAttributes(msrest.serialization.Model):
+    """EnvironmentAttributes.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar machine_learning_framework: Required.
+    :vartype machine_learning_framework: ~index_service_apis.models.VersionedAttribute
+    :ivar mpi: Required.
+    :vartype mpi: ~index_service_apis.models.VersionedAttribute
+    :ivar runtime: Required.
+    :vartype runtime: ~index_service_apis.models.VersionedAttribute
+    :ivar cuda: Required.
+    :vartype cuda: ~index_service_apis.models.CudaAttribute
+    :ivar purpose: Required.
+    :vartype purpose: ~index_service_apis.models.Purpose
+    :ivar os: Required.
+    :vartype os: ~index_service_apis.models.VersionedAttribute
+    """
+
+    _validation = {
+        "machine_learning_framework": {"required": True},
+        "mpi": {"required": True},
+        "runtime": {"required": True},
+        "cuda": {"required": True},
+        "purpose": {"required": True},
+        "os": {"required": True},
+    }
+
+    _attribute_map = {
+        "machine_learning_framework": {"key": "machineLearningFramework", "type": "VersionedAttribute"},
+        "mpi": {"key": "mpi", "type": "VersionedAttribute"},
+        "runtime": {"key": "runtime", "type": "VersionedAttribute"},
+        "cuda": {"key": "cuda", "type": "CudaAttribute"},
+        "purpose": {"key": "purpose", "type": "Purpose"},
+        "os": {"key": "os", "type": "VersionedAttribute"},
+    }
+
+    def __init__(
+        self,
+        *,
+        machine_learning_framework: "VersionedAttribute",
+        mpi: "VersionedAttribute",
+        runtime: "VersionedAttribute",
+        cuda: "CudaAttribute",
+        purpose: "Purpose",
+        os: "VersionedAttribute",
+        **kwargs
+    ):
+        """
+        :keyword machine_learning_framework: Required.
+        :paramtype machine_learning_framework: ~index_service_apis.models.VersionedAttribute
+        :keyword mpi: Required.
+        :paramtype mpi: ~index_service_apis.models.VersionedAttribute
+        :keyword runtime: Required.
+        :paramtype runtime: ~index_service_apis.models.VersionedAttribute
+        :keyword cuda: Required.
+        :paramtype cuda: ~index_service_apis.models.CudaAttribute
+        :keyword purpose: Required.
+        :paramtype purpose: ~index_service_apis.models.Purpose
+        :keyword os: Required.
+        :paramtype os: ~index_service_apis.models.VersionedAttribute
+        """
+        super(EnvironmentAttributes, self).__init__(**kwargs)
+        self.machine_learning_framework = machine_learning_framework
+        self.mpi = mpi
+        self.runtime = runtime
+        self.cuda = cuda
+        self.purpose = purpose
+        self.os = os
+
+
+class EnvironmentsVersionedEntitiesResponse(msrest.serialization.Model):
+    """EnvironmentsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.EnvironmentsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[EnvironmentsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["EnvironmentsVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.EnvironmentsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(EnvironmentsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class EnvironmentsVersionedEntity(msrest.serialization.Model):
+    """EnvironmentsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.DefinitionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.DefinitionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "DefinitionAnnotations"},
+        "properties": {"key": "properties", "type": "DefinitionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "EnvironmentsVersionedEntityKind"],
+        annotations: "DefinitionAnnotations",
+        properties: "DefinitionProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.DefinitionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.DefinitionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(EnvironmentsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class ErrorAdditionalInfo(msrest.serialization.Model):
+    """ErrorAdditionalInfo.
+
+    :ivar type:
+    :vartype type: str
+    :ivar info: Anything.
+    :vartype info: any
+    """
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "info": {"key": "info", "type": "object"},
+    }
+
+    def __init__(self, *, type: Optional[str] = None, info: Optional[Any] = None, **kwargs):
+        """
+        :keyword type:
+        :paramtype type: str
+        :keyword info: Anything.
+        :paramtype info: any
+        """
+        super(ErrorAdditionalInfo, self).__init__(**kwargs)
+        self.type = type
+        self.info = info
+
+
+class ErrorResponse(msrest.serialization.Model):
+    """ErrorResponse.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar error:
+    :vartype error: ~index_service_apis.models.RootError
+    :ivar correlation: Dictionary of :code:`<string>`.
+    :vartype correlation: dict[str, str]
+    :ivar environment:
+    :vartype environment: str
+    :ivar location:
+    :vartype location: str
+    :ivar time:
+    :vartype time: ~datetime.datetime
+    :ivar component_name:
+    :vartype component_name: str
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "error": {"key": "error", "type": "RootError"},
+        "correlation": {"key": "correlation", "type": "{str}"},
+        "environment": {"key": "environment", "type": "str"},
+        "location": {"key": "location", "type": "str"},
+        "time": {"key": "time", "type": "iso-8601"},
+        "component_name": {"key": "componentName", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        additional_properties: Optional[Dict[str, Any]] = None,
+        error: Optional["RootError"] = None,
+        correlation: Optional[Dict[str, str]] = None,
+        environment: Optional[str] = None,
+        location: Optional[str] = None,
+        time: Optional[datetime.datetime] = None,
+        component_name: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword error:
+        :paramtype error: ~index_service_apis.models.RootError
+        :keyword correlation: Dictionary of :code:`<string>`.
+        :paramtype correlation: dict[str, str]
+        :keyword environment:
+        :paramtype environment: str
+        :keyword location:
+        :paramtype location: str
+        :keyword time:
+        :paramtype time: ~datetime.datetime
+        :keyword component_name:
+        :paramtype component_name: str
+        """
+        super(ErrorResponse, self).__init__(**kwargs)
+        self.additional_properties = additional_properties
+        self.error = error
+        self.correlation = correlation
+        self.environment = environment
+        self.location = location
+        self.time = time
+        self.component_name = component_name
+
+
+class ExperimentStatus(msrest.serialization.Model):
+    """ExperimentStatus.
+
+    :ivar status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished",
+     "Canceled", "Failing".
+    :vartype status_code: str or ~index_service_apis.models.ExperimentStatusCode
+    :ivar status_detail:
+    :vartype status_detail: str
+    :ivar creation_time:
+    :vartype creation_time: ~datetime.datetime
+    :ivar end_time:
+    :vartype end_time: ~datetime.datetime
+    :ivar run_history_error_code:
+    :vartype run_history_error_code: str
+    """
+
+    _attribute_map = {
+        "status_code": {"key": "statusCode", "type": "str"},
+        "status_detail": {"key": "statusDetail", "type": "str"},
+        "creation_time": {"key": "creationTime", "type": "iso-8601"},
+        "end_time": {"key": "endTime", "type": "iso-8601"},
+        "run_history_error_code": {"key": "runHistoryErrorCode", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        status_code: Optional[Union[str, "ExperimentStatusCode"]] = None,
+        status_detail: Optional[str] = None,
+        creation_time: Optional[datetime.datetime] = None,
+        end_time: Optional[datetime.datetime] = None,
+        run_history_error_code: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished",
+         "Canceled", "Failing".
+        :paramtype status_code: str or ~index_service_apis.models.ExperimentStatusCode
+        :keyword status_detail:
+        :paramtype status_detail: str
+        :keyword creation_time:
+        :paramtype creation_time: ~datetime.datetime
+        :keyword end_time:
+        :paramtype end_time: ~datetime.datetime
+        :keyword run_history_error_code:
+        :paramtype run_history_error_code: str
+        """
+        super(ExperimentStatus, self).__init__(**kwargs)
+        self.status_code = status_code
+        self.status_detail = status_detail
+        self.creation_time = creation_time
+        self.end_time = end_time
+        self.run_history_error_code = run_history_error_code
+
+
+class Feature(msrest.serialization.Model):
+    """Feature.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar feature_name: Required.
+    :vartype feature_name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+     "Double", "Binary", "Datetime", "Boolean".
+    :vartype data_type: str or ~index_service_apis.models.FeatureDataType
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "feature_name": {"required": True},
+        "description": {"required": True},
+        "data_type": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "feature_name": {"key": "featureName", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "data_type": {"key": "dataType", "type": "str"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        feature_name: str,
+        description: str,
+        data_type: Union[str, "FeatureDataType"],
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword feature_name: Required.
+        :paramtype feature_name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+         "Double", "Binary", "Datetime", "Boolean".
+        :paramtype data_type: str or ~index_service_apis.models.FeatureDataType
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(Feature, self).__init__(**kwargs)
+        self.feature_name = feature_name
+        self.description = description
+        self.data_type = data_type
+        self.tags = tags
+
+
+class FeatureentitiesVersionedEntitiesResponse(msrest.serialization.Model):
+    """FeatureentitiesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[FeatureentitiesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["FeatureentitiesVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(FeatureentitiesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class FeatureentitiesVersionedEntity(msrest.serialization.Model):
+    """FeatureentitiesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"},
+        "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "FeatureentitiesVersionedEntityKind"],
+        annotations: "FeatureEntityVersionAnnotations",
+        properties: "FeatureEntityVersionProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(FeatureentitiesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class FeatureEntityVersionAnnotations(msrest.serialization.Model):
+    """FeatureEntityVersionAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar actual_name: Required.
+    :vartype actual_name: str
+    :ivar index_columns: Required.
+    :vartype index_columns: list[~index_service_apis.models.IndexColumnDto]
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "actual_name": {"required": True},
+        "index_columns": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "actual_name": {"key": "actualName", "type": "str"},
+        "index_columns": {"key": "indexColumns", "type": "[IndexColumnDto]"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        actual_name: str,
+        index_columns: List["IndexColumnDto"],
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword actual_name: Required.
+        :paramtype actual_name: str
+        :keyword index_columns: Required.
+        :paramtype index_columns: list[~index_service_apis.models.IndexColumnDto]
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(FeatureEntityVersionAnnotations, self).__init__(**kwargs)
+        self.actual_name = actual_name
+        self.index_columns = index_columns
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class FeatureEntityVersionProperties(msrest.serialization.Model):
+    """FeatureEntityVersionProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar feature_entity_name: Required.
+    :vartype feature_entity_name: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "feature_entity_name": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "feature_entity_name": {"key": "featureEntityName", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, feature_entity_name: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword feature_entity_name: Required.
+        :paramtype feature_entity_name: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(FeatureEntityVersionProperties, self).__init__(**kwargs)
+        self.feature_entity_name = feature_entity_name
+        self.creation_context = creation_context
+
+
+class FeaturesetSpecification(msrest.serialization.Model):
+    """FeaturesetSpecification.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar path: Required.
+    :vartype path: str
+    """
+
+    _validation = {
+        "path": {"required": True},
+    }
+
+    _attribute_map = {
+        "path": {"key": "path", "type": "str"},
+    }
+
+    def __init__(self, *, path: str, **kwargs):
+        """
+        :keyword path: Required.
+        :paramtype path: str
+        """
+        super(FeaturesetSpecification, self).__init__(**kwargs)
+        self.path = path
+
+
+class FeaturesetsVersionedEntitiesResponse(msrest.serialization.Model):
+    """FeaturesetsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.FeaturesetsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[FeaturesetsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["FeaturesetsVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.FeaturesetsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(FeaturesetsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class FeaturesetsVersionedEntity(msrest.serialization.Model):
+    """FeaturesetsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.FeatureSetVersionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "FeatureSetVersionAnnotations"},
+        "properties": {"key": "properties", "type": "FeatureSetVersionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "FeaturesetsVersionedEntityKind"],
+        annotations: "FeatureSetVersionAnnotations",
+        properties: "FeatureSetVersionProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.FeatureSetVersionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(FeaturesetsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class FeatureSetVersionAnnotations(msrest.serialization.Model):
+    """FeatureSetVersionAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar actual_name: Required.
+    :vartype actual_name: str
+    :ivar specification: Required.
+    :vartype specification: ~index_service_apis.models.FeaturesetSpecification
+    :ivar entities: Required.
+    :vartype entities: list[str]
+    :ivar features: Required.
+    :vartype features: list[~index_service_apis.models.Feature]
+    :ivar stage: Required.
+    :vartype stage: str
+    :ivar materialization_settings: Required.
+    :vartype materialization_settings: ~index_service_apis.models.MaterializationSettings
+    :ivar source: Required.
+    :vartype source: ~index_service_apis.models.FeatureSourceDto
+    :ivar feature_transformation_code: Required.
+    :vartype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto
+    :ivar temporal_join_lookback: Required.
+    :vartype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto
+    :ivar source_lookback: Required.
+    :vartype source_lookback: ~index_service_apis.models.TimeDeltaDto
+    :ivar timestamp_column: Required.
+    :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "actual_name": {"required": True},
+        "specification": {"required": True},
+        "entities": {"required": True},
+        "features": {"required": True},
+        "stage": {"required": True},
+        "materialization_settings": {"required": True},
+        "source": {"required": True},
+        "feature_transformation_code": {"required": True},
+        "temporal_join_lookback": {"required": True},
+        "source_lookback": {"required": True},
+        "timestamp_column": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "actual_name": {"key": "actualName", "type": "str"},
+        "specification": {"key": "specification", "type": "FeaturesetSpecification"},
+        "entities": {"key": "entities", "type": "[str]"},
+        "features": {"key": "features", "type": "[Feature]"},
+        "stage": {"key": "stage", "type": "str"},
+        "materialization_settings": {"key": "materializationSettings", "type": "MaterializationSettings"},
+        "source": {"key": "source", "type": "FeatureSourceDto"},
+        "feature_transformation_code": {"key": "featureTransformationCode", "type": "FeatureTransformationDto"},
+        "temporal_join_lookback": {"key": "temporalJoinLookback", "type": "TimeDeltaDto"},
+        "source_lookback": {"key": "sourceLookback", "type": "TimeDeltaDto"},
+        "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        actual_name: str,
+        specification: "FeaturesetSpecification",
+        entities: List[str],
+        features: List["Feature"],
+        stage: str,
+        materialization_settings: "MaterializationSettings",
+        source: "FeatureSourceDto",
+        feature_transformation_code: "FeatureTransformationDto",
+        temporal_join_lookback: "TimeDeltaDto",
+        source_lookback: "TimeDeltaDto",
+        timestamp_column: "TimestampColumnDto",
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword actual_name: Required.
+        :paramtype actual_name: str
+        :keyword specification: Required.
+        :paramtype specification: ~index_service_apis.models.FeaturesetSpecification
+        :keyword entities: Required.
+        :paramtype entities: list[str]
+        :keyword features: Required.
+        :paramtype features: list[~index_service_apis.models.Feature]
+        :keyword stage: Required.
+        :paramtype stage: str
+        :keyword materialization_settings: Required.
+        :paramtype materialization_settings: ~index_service_apis.models.MaterializationSettings
+        :keyword source: Required.
+        :paramtype source: ~index_service_apis.models.FeatureSourceDto
+        :keyword feature_transformation_code: Required.
+        :paramtype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto
+        :keyword temporal_join_lookback: Required.
+        :paramtype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto
+        :keyword source_lookback: Required.
+        :paramtype source_lookback: ~index_service_apis.models.TimeDeltaDto
+        :keyword timestamp_column: Required.
+        :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(FeatureSetVersionAnnotations, self).__init__(**kwargs)
+        self.actual_name = actual_name
+        self.specification = specification
+        self.entities = entities
+        self.features = features
+        self.stage = stage
+        self.materialization_settings = materialization_settings
+        self.source = source
+        self.feature_transformation_code = feature_transformation_code
+        self.temporal_join_lookback = temporal_join_lookback
+        self.source_lookback = source_lookback
+        self.timestamp_column = timestamp_column
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class FeatureSetVersionProperties(msrest.serialization.Model):
+    """FeatureSetVersionProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar feature_set_name: Required.
+    :vartype feature_set_name: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "feature_set_name": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "feature_set_name": {"key": "featureSetName", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, feature_set_name: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword feature_set_name: Required.
+        :paramtype feature_set_name: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(FeatureSetVersionProperties, self).__init__(**kwargs)
+        self.feature_set_name = feature_set_name
+        self.creation_context = creation_context
+
+
+class FeatureSourceDto(msrest.serialization.Model):
+    """FeatureSourceDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar type: Required. Possible values include: "mltable", "csv", "parquet".
+    :vartype type: str or ~index_service_apis.models.FeatureSourceDtoType
+    :ivar path: Required.
+    :vartype path: str
+    :ivar timestamp_column: Required.
+    :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+    :ivar source_delay: Required.
+    :vartype source_delay: ~index_service_apis.models.TimeDeltaDto
+    """
+
+    _validation = {
+        "type": {"required": True},
+        "path": {"required": True},
+        "timestamp_column": {"required": True},
+        "source_delay": {"required": True},
+    }
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "path": {"key": "path", "type": "str"},
+        "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"},
+        "source_delay": {"key": "sourceDelay", "type": "TimeDeltaDto"},
+    }
+
+    def __init__(
+        self,
+        *,
+        type: Union[str, "FeatureSourceDtoType"],
+        path: str,
+        timestamp_column: "TimestampColumnDto",
+        source_delay: "TimeDeltaDto",
+        **kwargs
+    ):
+        """
+        :keyword type: Required. Possible values include: "mltable", "csv", "parquet".
+        :paramtype type: str or ~index_service_apis.models.FeatureSourceDtoType
+        :keyword path: Required.
+        :paramtype path: str
+        :keyword timestamp_column: Required.
+        :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto
+        :keyword source_delay: Required.
+        :paramtype source_delay: ~index_service_apis.models.TimeDeltaDto
+        """
+        super(FeatureSourceDto, self).__init__(**kwargs)
+        self.type = type
+        self.path = path
+        self.timestamp_column = timestamp_column
+        self.source_delay = source_delay
+
+
+class FeaturestoreentitiesVersionedEntitiesResponse(msrest.serialization.Model):
+    """FeaturestoreentitiesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[FeaturestoreentitiesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["FeaturestoreentitiesVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(FeaturestoreentitiesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class FeaturestoreentitiesVersionedEntity(msrest.serialization.Model):
+    """FeaturestoreentitiesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"},
+        "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "FeaturestoreentitiesVersionedEntityKind"],
+        annotations: "FeatureEntityVersionAnnotations",
+        properties: "FeatureEntityVersionProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(FeaturestoreentitiesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class FeatureTransformationDto(msrest.serialization.Model):
+    """FeatureTransformationDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar path: Required.
+    :vartype path: str
+    :ivar transformer_class: Required.
+    :vartype transformer_class: str
+    """
+
+    _validation = {
+        "path": {"required": True},
+        "transformer_class": {"required": True},
+    }
+
+    _attribute_map = {
+        "path": {"key": "path", "type": "str"},
+        "transformer_class": {"key": "transformerClass", "type": "str"},
+    }
+
+    def __init__(self, *, path: str, transformer_class: str, **kwargs):
+        """
+        :keyword path: Required.
+        :paramtype path: str
+        :keyword transformer_class: Required.
+        :paramtype transformer_class: str
+        """
+        super(FeatureTransformationDto, self).__init__(**kwargs)
+        self.path = path
+        self.transformer_class = transformer_class
+
+
+class FreeTextSearchColumn(msrest.serialization.Model):
+    """FreeTextSearchColumn.
+
+    :ivar name:
+    :vartype name: str
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+    }
+
+    def __init__(self, *, name: Optional[str] = None, **kwargs):
+        """
+        :keyword name:
+        :paramtype name: str
+        """
+        super(FreeTextSearchColumn, self).__init__(**kwargs)
+        self.name = name
+
+
+class GenericTriggerAnnotations(msrest.serialization.Model):
+    """GenericTriggerAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar display_name: Required.
+    :vartype display_name: str
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar provisioning_status: Required. Possible values include: "Completed", "Provisioning",
+     "Failed".
+    :vartype provisioning_status: str or
+     ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus
+    :ivar trigger_type: Required. Possible values include: "Schedule", "Once".
+    :vartype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType
+    :ivar schedule_method: Required. Possible values include: "Cron", "Recurrence".
+    :vartype schedule_method: str or
+     ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod
+    :ivar schedule_action_type: Required. Possible values include: "CreateJob", "InvokeEndpoint",
+     "ImportData", "ModelMonitor".
+    :vartype schedule_action_type: str or
+     ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType
+    :ivar recurrence: Required.
+    :vartype recurrence: ~index_service_apis.models.RecurrenceTrigger
+    :ivar cron: Required.
+    :vartype cron: ~index_service_apis.models.CronTrigger
+    :ivar start_time: Required.
+    :vartype start_time: str
+    :ivar end_time: Required.
+    :vartype end_time: str
+    :ivar time_zone: Required.
+    :vartype time_zone: str
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar definition: Required.
+    :vartype definition: str
+    :ivar feature_definition: Required.
+    :vartype feature_definition: str
+    :ivar managed_type: Required. Possible values include: "Customer", "System".
+    :vartype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType
+    :ivar scenario_name: Required.
+    :vartype scenario_name: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "display_name": {"required": True},
+        "kv_tags": {"required": True},
+        "properties": {"required": True},
+        "provisioning_status": {"required": True},
+        "trigger_type": {"required": True},
+        "schedule_method": {"required": True},
+        "schedule_action_type": {"required": True},
+        "recurrence": {"required": True},
+        "cron": {"required": True},
+        "start_time": {"required": True},
+        "end_time": {"required": True},
+        "time_zone": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "definition": {"required": True},
+        "feature_definition": {"required": True},
+        "managed_type": {"required": True},
+        "scenario_name": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "display_name": {"key": "displayName", "type": "str"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "provisioning_status": {"key": "provisioningStatus", "type": "str"},
+        "trigger_type": {"key": "triggerType", "type": "str"},
+        "schedule_method": {"key": "scheduleMethod", "type": "str"},
+        "schedule_action_type": {"key": "scheduleActionType", "type": "str"},
+        "recurrence": {"key": "recurrence", "type": "RecurrenceTrigger"},
+        "cron": {"key": "cron", "type": "CronTrigger"},
+        "start_time": {"key": "startTime", "type": "str"},
+        "end_time": {"key": "endTime", "type": "str"},
+        "time_zone": {"key": "timeZone", "type": "str"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "definition": {"key": "definition", "type": "str"},
+        "feature_definition": {"key": "featureDefinition", "type": "str"},
+        "managed_type": {"key": "managedType", "type": "str"},
+        "scenario_name": {"key": "scenarioName", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        display_name: str,
+        kv_tags: Dict[str, str],
+        properties: Dict[str, str],
+        provisioning_status: Union[str, "GenericTriggerAnnotationsProvisioningStatus"],
+        trigger_type: Union[str, "GenericTriggerAnnotationsTriggerType"],
+        schedule_method: Union[str, "GenericTriggerAnnotationsScheduleMethod"],
+        schedule_action_type: Union[str, "GenericTriggerAnnotationsScheduleActionType"],
+        recurrence: "RecurrenceTrigger",
+        cron: "CronTrigger",
+        start_time: str,
+        end_time: str,
+        time_zone: str,
+        entity_status: Union[str, "GenericTriggerAnnotationsEntityStatus"],
+        last_modified_date: datetime.datetime,
+        last_updated_by: "CreatedBy",
+        definition: str,
+        feature_definition: str,
+        managed_type: Union[str, "GenericTriggerAnnotationsManagedType"],
+        scenario_name: str,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword display_name: Required.
+        :paramtype display_name: str
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword provisioning_status: Required. Possible values include: "Completed", "Provisioning",
+         "Failed".
+        :paramtype provisioning_status: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus
+        :keyword trigger_type: Required. Possible values include: "Schedule", "Once".
+        :paramtype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType
+        :keyword schedule_method: Required. Possible values include: "Cron", "Recurrence".
+        :paramtype schedule_method: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod
+        :keyword schedule_action_type: Required. Possible values include: "CreateJob",
+         "InvokeEndpoint", "ImportData", "ModelMonitor".
+        :paramtype schedule_action_type: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType
+        :keyword recurrence: Required.
+        :paramtype recurrence: ~index_service_apis.models.RecurrenceTrigger
+        :keyword cron: Required.
+        :paramtype cron: ~index_service_apis.models.CronTrigger
+        :keyword start_time: Required.
+        :paramtype start_time: str
+        :keyword end_time: Required.
+        :paramtype end_time: str
+        :keyword time_zone: Required.
+        :paramtype time_zone: str
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or
+         ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword definition: Required.
+        :paramtype definition: str
+        :keyword feature_definition: Required.
+        :paramtype feature_definition: str
+        :keyword managed_type: Required. Possible values include: "Customer", "System".
+        :paramtype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType
+        :keyword scenario_name: Required.
+        :paramtype scenario_name: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(GenericTriggerAnnotations, self).__init__(**kwargs)
+        self.display_name = display_name
+        self.kv_tags = kv_tags
+        self.properties = properties
+        self.provisioning_status = provisioning_status
+        self.trigger_type = trigger_type
+        self.schedule_method = schedule_method
+        self.schedule_action_type = schedule_action_type
+        self.recurrence = recurrence
+        self.cron = cron
+        self.start_time = start_time
+        self.end_time = end_time
+        self.time_zone = time_zone
+        self.entity_status = entity_status
+        self.last_modified_date = last_modified_date
+        self.last_updated_by = last_updated_by
+        self.definition = definition
+        self.feature_definition = feature_definition
+        self.managed_type = managed_type
+        self.scenario_name = scenario_name
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class GenericTriggerProperties(msrest.serialization.Model):
+    """GenericTriggerProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(GenericTriggerProperties, self).__init__(**kwargs)
+        self.id = id
+        self.creation_context = creation_context
+
+
+class GenerictriggersUnversionedEntitiesResponse(msrest.serialization.Model):
+    """GenerictriggersUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[GenerictriggersUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["GenerictriggersUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(GenerictriggersUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class GenerictriggersUnversionedEntity(msrest.serialization.Model):
+    """GenerictriggersUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.GenericTriggerAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.GenericTriggerProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "GenericTriggerAnnotations"},
+        "properties": {"key": "properties", "type": "GenericTriggerProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "GenerictriggersUnversionedEntityKind"],
+        annotations: "GenericTriggerAnnotations",
+        properties: "GenericTriggerProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.GenericTriggerAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.GenericTriggerProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(GenerictriggersUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class HighlightOptions(msrest.serialization.Model):
+    """HighlightOptions.
+
+    :ivar pre_tag:
+    :vartype pre_tag: str
+    :ivar post_tag:
+    :vartype post_tag: str
+    :ivar fields:
+    :vartype fields: list[str]
+    """
+
+    _attribute_map = {
+        "pre_tag": {"key": "preTag", "type": "str"},
+        "post_tag": {"key": "postTag", "type": "str"},
+        "fields": {"key": "fields", "type": "[str]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        pre_tag: Optional[str] = None,
+        post_tag: Optional[str] = None,
+        fields: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        :keyword pre_tag:
+        :paramtype pre_tag: str
+        :keyword post_tag:
+        :paramtype post_tag: str
+        :keyword fields:
+        :paramtype fields: list[str]
+        """
+        super(HighlightOptions, self).__init__(**kwargs)
+        self.pre_tag = pre_tag
+        self.post_tag = post_tag
+        self.fields = fields
+
+
+class IndependentPipelineAnnotations(msrest.serialization.Model):
+    """IndependentPipelineAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar url: Required.
+    :vartype url: str
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or
+     ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar last_run_id: Required.
+    :vartype last_run_id: str
+    :ivar pipeline_type: Required.
+    :vartype pipeline_type: str
+    :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+     "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+    :vartype last_run_status_code: str or
+     ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode
+    :ivar last_run_creation_time: Required.
+    :vartype last_run_creation_time: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "url": {"required": True},
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "last_run_id": {"required": True},
+        "pipeline_type": {"required": True},
+        "last_run_status_code": {"required": True},
+        "last_run_creation_time": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "url": {"key": "url", "type": "str"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "last_run_id": {"key": "lastRunId", "type": "str"},
+        "pipeline_type": {"key": "pipelineType", "type": "str"},
+        "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"},
+        "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        url: str,
+        kv_tags: Dict[str, str],
+        step_tags: Dict[str, str],
+        properties: Dict[str, str],
+        step_properties: Dict[str, str],
+        entity_status: Union[str, "IndependentPipelineAnnotationsEntityStatus"],
+        last_modified_date: datetime.datetime,
+        last_updated_by: "CreatedBy",
+        last_run_id: str,
+        pipeline_type: str,
+        last_run_status_code: Union[str, "IndependentPipelineAnnotationsLastRunStatusCode"],
+        last_run_creation_time: datetime.datetime,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword url: Required.
+        :paramtype url: str
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or
+         ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword last_run_id: Required.
+        :paramtype last_run_id: str
+        :keyword pipeline_type: Required.
+        :paramtype pipeline_type: str
+        :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+         "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+        :paramtype last_run_status_code: str or
+         ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode
+        :keyword last_run_creation_time: Required.
+        :paramtype last_run_creation_time: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(IndependentPipelineAnnotations, self).__init__(**kwargs)
+        self.url = url
+        self.kv_tags = kv_tags
+        self.step_tags = step_tags
+        self.properties = properties
+        self.step_properties = step_properties
+        self.entity_status = entity_status
+        self.last_modified_date = last_modified_date
+        self.last_updated_by = last_updated_by
+        self.last_run_id = last_run_id
+        self.pipeline_type = pipeline_type
+        self.last_run_status_code = last_run_status_code
+        self.last_run_creation_time = last_run_creation_time
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class IndependentPipelineProperties(msrest.serialization.Model):
+    """IndependentPipelineProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(IndependentPipelineProperties, self).__init__(**kwargs)
+        self.id = id
+        self.creation_context = creation_context
+
+
+class IndependentpipelinesUnversionedEntitiesResponse(msrest.serialization.Model):
+    """IndependentpipelinesUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[IndependentpipelinesUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["IndependentpipelinesUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(IndependentpipelinesUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class IndependentpipelinesUnversionedEntity(msrest.serialization.Model):
+    """IndependentpipelinesUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.IndependentPipelineAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.IndependentPipelineProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "IndependentPipelineAnnotations"},
+        "properties": {"key": "properties", "type": "IndependentPipelineProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "IndependentpipelinesUnversionedEntityKind"],
+        annotations: "IndependentPipelineAnnotations",
+        properties: "IndependentPipelineProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.IndependentPipelineAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.IndependentPipelineProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(IndependentpipelinesUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class IndexAnnotations(msrest.serialization.Model):
+    """IndexAnnotations.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar archived:
+    :vartype archived: bool
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        additional_properties: Optional[Dict[str, Any]] = None,
+        archived: Optional[bool] = None,
+        tags: Optional[Dict[str, str]] = None,
+        **kwargs
+    ):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword archived:
+        :paramtype archived: bool
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(IndexAnnotations, self).__init__(**kwargs)
+        self.additional_properties = additional_properties
+        self.archived = archived
+        self.tags = tags
+
+
+class IndexColumn(msrest.serialization.Model):
+    """IndexColumn.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+     "Double", "Binary", "Datetime", "Boolean".
+    :vartype data_type: str or ~index_service_apis.models.IndexColumnDataType
+    :ivar column_name: Required.
+    :vartype column_name: str
+    """
+
+    _validation = {
+        "data_type": {"required": True},
+        "column_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "data_type": {"key": "dataType", "type": "str"},
+        "column_name": {"key": "columnName", "type": "str"},
+    }
+
+    def __init__(self, *, data_type: Union[str, "IndexColumnDataType"], column_name: str, **kwargs):
+        """
+        :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float",
+         "Double", "Binary", "Datetime", "Boolean".
+        :paramtype data_type: str or ~index_service_apis.models.IndexColumnDataType
+        :keyword column_name: Required.
+        :paramtype column_name: str
+        """
+        super(IndexColumn, self).__init__(**kwargs)
+        self.data_type = data_type
+        self.column_name = column_name
+
+
+class IndexColumnDto(msrest.serialization.Model):
+    """IndexColumnDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar type: Required. Possible values include: "string", "integer", "long", "float", "double",
+     "binary", "datetime", "boolean".
+    :vartype type: str or ~index_service_apis.models.IndexColumnDtoType
+    :ivar name: Required.
+    :vartype name: str
+    """
+
+    _validation = {
+        "type": {"required": True},
+        "name": {"required": True},
+    }
+
+    _attribute_map = {
+        "type": {"key": "type", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+    }
+
+    def __init__(self, *, type: Union[str, "IndexColumnDtoType"], name: str, **kwargs):
+        """
+        :keyword type: Required. Possible values include: "string", "integer", "long", "float",
+         "double", "binary", "datetime", "boolean".
+        :paramtype type: str or ~index_service_apis.models.IndexColumnDtoType
+        :keyword name: Required.
+        :paramtype name: str
+        """
+        super(IndexColumnDto, self).__init__(**kwargs)
+        self.type = type
+        self.name = name
+
+
+class IndexedErrorResponse(msrest.serialization.Model):
+    """IndexedErrorResponse.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar code: Required.
+    :vartype code: str
+    :ivar error_code_hierarchy: Required.
+    :vartype error_code_hierarchy: str
+    :ivar message: Required.
+    :vartype message: str
+    :ivar time: Required.
+    :vartype time: ~datetime.datetime
+    :ivar component_name: Required.
+    :vartype component_name: str
+    :ivar severity: Required.
+    :vartype severity: int
+    :ivar details_uri: Required.
+    :vartype details_uri: str
+    :ivar reference_code: Required.
+    :vartype reference_code: str
+    """
+
+    _validation = {
+        "code": {"required": True},
+        "error_code_hierarchy": {"required": True},
+        "message": {"required": True},
+        "time": {"required": True},
+        "component_name": {"required": True},
+        "severity": {"required": True},
+        "details_uri": {"required": True},
+        "reference_code": {"required": True},
+    }
+
+    _attribute_map = {
+        "code": {"key": "code", "type": "str"},
+        "error_code_hierarchy": {"key": "errorCodeHierarchy", "type": "str"},
+        "message": {"key": "message", "type": "str"},
+        "time": {"key": "time", "type": "iso-8601"},
+        "component_name": {"key": "componentName", "type": "str"},
+        "severity": {"key": "severity", "type": "int"},
+        "details_uri": {"key": "detailsUri", "type": "str"},
+        "reference_code": {"key": "referenceCode", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        code: str,
+        error_code_hierarchy: str,
+        message: str,
+        time: datetime.datetime,
+        component_name: str,
+        severity: int,
+        details_uri: str,
+        reference_code: str,
+        **kwargs
+    ):
+        """
+        :keyword code: Required.
+        :paramtype code: str
+        :keyword error_code_hierarchy: Required.
+        :paramtype error_code_hierarchy: str
+        :keyword message: Required.
+        :paramtype message: str
+        :keyword time: Required.
+        :paramtype time: ~datetime.datetime
+        :keyword component_name: Required.
+        :paramtype component_name: str
+        :keyword severity: Required.
+        :paramtype severity: int
+        :keyword details_uri: Required.
+        :paramtype details_uri: str
+        :keyword reference_code: Required.
+        :paramtype reference_code: str
+        """
+        super(IndexedErrorResponse, self).__init__(**kwargs)
+        self.code = code
+        self.error_code_hierarchy = error_code_hierarchy
+        self.message = message
+        self.time = time
+        self.component_name = component_name
+        self.severity = severity
+        self.details_uri = details_uri
+        self.reference_code = reference_code
+
+
+class IndexEntitiesLocalOperationRequest(msrest.serialization.Model):
+    """IndexEntitiesLocalOperationRequest.
+
+    :ivar get_all_entities:
+    :vartype get_all_entities: bool
+    :ivar group:
+    :vartype group: list[~index_service_apis.models.IndexEntitiesRequestGroup]
+    :ivar highlight_options:
+    :vartype highlight_options: ~index_service_apis.models.HighlightOptions
+    :ivar search_builder:
+    :vartype search_builder: str
+    :ivar search_mode:
+    :vartype search_mode: str
+    :ivar free_text_search:
+    :vartype free_text_search: str
+    :ivar free_text_search_columns:
+    :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+    :ivar filters:
+    :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar asset_resource_filters:
+    :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar order:
+    :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+    :ivar page_size:
+    :vartype page_size: int
+    :ivar skip:
+    :vartype skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar include_total_result_count:
+    :vartype include_total_result_count: bool
+    :ivar resources:
+    :vartype resources: list[~index_service_apis.models.ResourceInformation]
+    :ivar cmk_fanout:
+    :vartype cmk_fanout: bool
+    :ivar include_fanout_data:
+    :vartype include_fanout_data: bool
+    :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    """
+
+    _attribute_map = {
+        "get_all_entities": {"key": "getAllEntities", "type": "bool"},
+        "group": {"key": "group", "type": "[IndexEntitiesRequestGroup]"},
+        "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"},
+        "search_builder": {"key": "searchBuilder", "type": "str"},
+        "search_mode": {"key": "searchMode", "type": "str"},
+        "free_text_search": {"key": "freeTextSearch", "type": "str"},
+        "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"},
+        "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"},
+        "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"},
+        "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"},
+        "page_size": {"key": "pageSize", "type": "int"},
+        "skip": {"key": "skip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"},
+        "resources": {"key": "resources", "type": "[ResourceInformation]"},
+        "cmk_fanout": {"key": "cmkFanout", "type": "bool"},
+        "include_fanout_data": {"key": "includeFanoutData", "type": "bool"},
+        "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        get_all_entities: Optional[bool] = None,
+        group: Optional[List["IndexEntitiesRequestGroup"]] = None,
+        highlight_options: Optional["HighlightOptions"] = None,
+        search_builder: Optional[str] = None,
+        search_mode: Optional[str] = None,
+        free_text_search: Optional[str] = None,
+        free_text_search_columns: Optional[List["FreeTextSearchColumn"]] = None,
+        filters: Optional[List["IndexEntitiesRequestFilter"]] = None,
+        asset_resource_filters: Optional[List["IndexEntitiesRequestFilter"]] = None,
+        order: Optional[List["IndexEntitiesRequestOrder"]] = None,
+        page_size: Optional[int] = None,
+        skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        include_total_result_count: Optional[bool] = None,
+        resources: Optional[List["ResourceInformation"]] = None,
+        cmk_fanout: Optional[bool] = None,
+        include_fanout_data: Optional[bool] = None,
+        shard_id_to_shard_skips: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        **kwargs
+    ):
+        """
+        :keyword get_all_entities:
+        :paramtype get_all_entities: bool
+        :keyword group:
+        :paramtype group: list[~index_service_apis.models.IndexEntitiesRequestGroup]
+        :keyword highlight_options:
+        :paramtype highlight_options: ~index_service_apis.models.HighlightOptions
+        :keyword search_builder:
+        :paramtype search_builder: str
+        :keyword search_mode:
+        :paramtype search_mode: str
+        :keyword free_text_search:
+        :paramtype free_text_search: str
+        :keyword free_text_search_columns:
+        :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+        :keyword filters:
+        :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword asset_resource_filters:
+        :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword order:
+        :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+        :keyword page_size:
+        :paramtype page_size: int
+        :keyword skip:
+        :paramtype skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword include_total_result_count:
+        :paramtype include_total_result_count: bool
+        :keyword resources:
+        :paramtype resources: list[~index_service_apis.models.ResourceInformation]
+        :keyword cmk_fanout:
+        :paramtype cmk_fanout: bool
+        :keyword include_fanout_data:
+        :paramtype include_fanout_data: bool
+        :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        """
+        super(IndexEntitiesLocalOperationRequest, self).__init__(**kwargs)
+        self.get_all_entities = get_all_entities
+        self.group = group
+        self.highlight_options = highlight_options
+        self.search_builder = search_builder
+        self.search_mode = search_mode
+        self.free_text_search = free_text_search
+        self.free_text_search_columns = free_text_search_columns
+        self.filters = filters
+        self.asset_resource_filters = asset_resource_filters
+        self.order = order
+        self.page_size = page_size
+        self.skip = skip
+        self.continuation_token = continuation_token
+        self.include_total_result_count = include_total_result_count
+        self.resources = resources
+        self.cmk_fanout = cmk_fanout
+        self.include_fanout_data = include_fanout_data
+        self.shard_id_to_shard_skips = shard_id_to_shard_skips
+
+
+class IndexEntitiesRequest(msrest.serialization.Model):
+    """IndexEntitiesRequest.
+
+    :ivar highlight_options:
+    :vartype highlight_options: ~index_service_apis.models.HighlightOptions
+    :ivar search_builder:
+    :vartype search_builder: str
+    :ivar search_mode:
+    :vartype search_mode: str
+    :ivar free_text_search:
+    :vartype free_text_search: str
+    :ivar free_text_search_columns:
+    :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+    :ivar filters:
+    :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar asset_resource_filters:
+    :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar order:
+    :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+    :ivar page_size:
+    :vartype page_size: int
+    :ivar skip:
+    :vartype skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar include_total_result_count:
+    :vartype include_total_result_count: bool
+    :ivar resources:
+    :vartype resources: list[~index_service_apis.models.ResourceInformation]
+    :ivar cmk_fanout:
+    :vartype cmk_fanout: bool
+    :ivar include_fanout_data:
+    :vartype include_fanout_data: bool
+    :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    """
+
+    _attribute_map = {
+        "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"},
+        "search_builder": {"key": "searchBuilder", "type": "str"},
+        "search_mode": {"key": "searchMode", "type": "str"},
+        "free_text_search": {"key": "freeTextSearch", "type": "str"},
+        "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"},
+        "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"},
+        "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"},
+        "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"},
+        "page_size": {"key": "pageSize", "type": "int"},
+        "skip": {"key": "skip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"},
+        "resources": {"key": "resources", "type": "[ResourceInformation]"},
+        "cmk_fanout": {"key": "cmkFanout", "type": "bool"},
+        "include_fanout_data": {"key": "includeFanoutData", "type": "bool"},
+        "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        highlight_options: Optional["HighlightOptions"] = None,
+        search_builder: Optional[str] = None,
+        search_mode: Optional[str] = None,
+        free_text_search: Optional[str] = None,
+        free_text_search_columns: Optional[List["FreeTextSearchColumn"]] = None,
+        filters: Optional[List["IndexEntitiesRequestFilter"]] = None,
+        asset_resource_filters: Optional[List["IndexEntitiesRequestFilter"]] = None,
+        order: Optional[List["IndexEntitiesRequestOrder"]] = None,
+        page_size: Optional[int] = None,
+        skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        include_total_result_count: Optional[bool] = None,
+        resources: Optional[List["ResourceInformation"]] = None,
+        cmk_fanout: Optional[bool] = None,
+        include_fanout_data: Optional[bool] = None,
+        shard_id_to_shard_skips: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        **kwargs
+    ):
+        """
+        :keyword highlight_options:
+        :paramtype highlight_options: ~index_service_apis.models.HighlightOptions
+        :keyword search_builder:
+        :paramtype search_builder: str
+        :keyword search_mode:
+        :paramtype search_mode: str
+        :keyword free_text_search:
+        :paramtype free_text_search: str
+        :keyword free_text_search_columns:
+        :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn]
+        :keyword filters:
+        :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword asset_resource_filters:
+        :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword order:
+        :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder]
+        :keyword page_size:
+        :paramtype page_size: int
+        :keyword skip:
+        :paramtype skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword include_total_result_count:
+        :paramtype include_total_result_count: bool
+        :keyword resources:
+        :paramtype resources: list[~index_service_apis.models.ResourceInformation]
+        :keyword cmk_fanout:
+        :paramtype cmk_fanout: bool
+        :keyword include_fanout_data:
+        :paramtype include_fanout_data: bool
+        :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        """
+        super(IndexEntitiesRequest, self).__init__(**kwargs)
+        self.highlight_options = highlight_options
+        self.search_builder = search_builder
+        self.search_mode = search_mode
+        self.free_text_search = free_text_search
+        self.free_text_search_columns = free_text_search_columns
+        self.filters = filters
+        self.asset_resource_filters = asset_resource_filters
+        self.order = order
+        self.page_size = page_size
+        self.skip = skip
+        self.continuation_token = continuation_token
+        self.include_total_result_count = include_total_result_count
+        self.resources = resources
+        self.cmk_fanout = cmk_fanout
+        self.include_fanout_data = include_fanout_data
+        self.shard_id_to_shard_skips = shard_id_to_shard_skips
+
+
+class IndexEntitiesRequestFilter(msrest.serialization.Model):
+    """IndexEntitiesRequestFilter.
+
+    :ivar field:
+    :vartype field: str
+    :ivar operator:
+    :vartype operator: str
+    :ivar values:
+    :vartype values: list[str]
+    """
+
+    _attribute_map = {
+        "field": {"key": "field", "type": "str"},
+        "operator": {"key": "operator", "type": "str"},
+        "values": {"key": "values", "type": "[str]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        field: Optional[str] = None,
+        operator: Optional[str] = None,
+        values: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        :keyword field:
+        :paramtype field: str
+        :keyword operator:
+        :paramtype operator: str
+        :keyword values:
+        :paramtype values: list[str]
+        """
+        super(IndexEntitiesRequestFilter, self).__init__(**kwargs)
+        self.field = field
+        self.operator = operator
+        self.values = values
+
+
+class IndexEntitiesRequestGroup(msrest.serialization.Model):
+    """IndexEntitiesRequestGroup.
+
+    :ivar field:
+    :vartype field: str
+    """
+
+    _attribute_map = {
+        "field": {"key": "field", "type": "str"},
+    }
+
+    def __init__(self, *, field: Optional[str] = None, **kwargs):
+        """
+        :keyword field:
+        :paramtype field: str
+        """
+        super(IndexEntitiesRequestGroup, self).__init__(**kwargs)
+        self.field = field
+
+
+class IndexEntitiesRequestOrder(msrest.serialization.Model):
+    """IndexEntitiesRequestOrder.
+
+    :ivar field:
+    :vartype field: str
+    :ivar direction: Possible values include: "Asc", "Desc".
+    :vartype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection
+    """
+
+    _attribute_map = {
+        "field": {"key": "field", "type": "str"},
+        "direction": {"key": "direction", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        field: Optional[str] = None,
+        direction: Optional[Union[str, "IndexEntitiesRequestOrderDirection"]] = None,
+        **kwargs
+    ):
+        """
+        :keyword field:
+        :paramtype field: str
+        :keyword direction: Possible values include: "Asc", "Desc".
+        :paramtype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection
+        """
+        super(IndexEntitiesRequestOrder, self).__init__(**kwargs)
+        self.field = field
+        self.direction = direction
+
+
+class IndexEntitiesResponse(msrest.serialization.Model):
+    """IndexEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.IndexEntityResponse]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[IndexEntityResponse]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["IndexEntityResponse"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.IndexEntityResponse]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(IndexEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class IndexEntityContainerMetadata(msrest.serialization.Model):
+    """IndexEntityContainerMetadata.
+
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group:
+    :vartype resource_group: str
+    :ivar resource_name:
+    :vartype resource_name: str
+    :ivar entity_container_type:
+    :vartype entity_container_type: str
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    :ivar tenant_id:
+    :vartype tenant_id: str
+    :ivar immutable_resource_id:
+    :vartype immutable_resource_id: str
+    :ivar is_public_resource:
+    :vartype is_public_resource: bool
+    """
+
+    _attribute_map = {
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group": {"key": "resourceGroup", "type": "str"},
+        "resource_name": {"key": "resourceName", "type": "str"},
+        "entity_container_type": {"key": "entityContainerType", "type": "str"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+        "tenant_id": {"key": "tenantId", "type": "str"},
+        "immutable_resource_id": {"key": "immutableResourceId", "type": "str"},
+        "is_public_resource": {"key": "isPublicResource", "type": "bool"},
+    }
+
+    def __init__(
+        self,
+        *,
+        resource_id: Optional[str] = None,
+        subscription_id: Optional[str] = None,
+        resource_group: Optional[str] = None,
+        resource_name: Optional[str] = None,
+        entity_container_type: Optional[str] = None,
+        regions: Optional[List["ResourceRegion"]] = None,
+        tenant_id: Optional[str] = None,
+        immutable_resource_id: Optional[str] = None,
+        is_public_resource: Optional[bool] = None,
+        **kwargs
+    ):
+        """
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group:
+        :paramtype resource_group: str
+        :keyword resource_name:
+        :paramtype resource_name: str
+        :keyword entity_container_type:
+        :paramtype entity_container_type: str
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        :keyword tenant_id:
+        :paramtype tenant_id: str
+        :keyword immutable_resource_id:
+        :paramtype immutable_resource_id: str
+        :keyword is_public_resource:
+        :paramtype is_public_resource: bool
+        """
+        super(IndexEntityContainerMetadata, self).__init__(**kwargs)
+        self.resource_id = resource_id
+        self.subscription_id = subscription_id
+        self.resource_group = resource_group
+        self.resource_name = resource_name
+        self.entity_container_type = entity_container_type
+        self.regions = regions
+        self.tenant_id = tenant_id
+        self.immutable_resource_id = immutable_resource_id
+        self.is_public_resource = is_public_resource
+
+
+class IndexEntityResponse(msrest.serialization.Model):
+    """IndexEntityResponse.
+
+    Variables are only populated by the server, and will be ignored when sending a request.
+
+    :ivar relevancy_score:
+    :vartype relevancy_score: float
+    :ivar entity_resource_name:
+    :vartype entity_resource_name: str
+    :ivar highlights: Dictionary of
+     <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>.
+    :vartype highlights: dict[str, list[str]]
+    :ivar usage:
+    :vartype usage: ~index_service_apis.models.Usage
+    :ivar schema_id:
+    :vartype schema_id: str
+    :ivar entity_id:
+    :vartype entity_id: str
+    :ivar kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.EntityKind
+    :ivar annotations:
+    :vartype annotations: ~index_service_apis.models.IndexAnnotations
+    :ivar properties:
+    :vartype properties: ~index_service_apis.models.IndexProperties
+    :ivar internal: Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence:
+    :vartype update_sequence: long
+    :ivar type:
+    :vartype type: str
+    :ivar version:
+    :vartype version: str
+    :ivar entity_container_id:
+    :vartype entity_container_id: str
+    :ivar entity_object_id:
+    :vartype entity_object_id: str
+    :ivar resource_type:
+    :vartype resource_type: str
+    :ivar relationships:
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "version": {"readonly": True},
+        "entity_container_id": {"readonly": True},
+        "entity_object_id": {"readonly": True},
+        "resource_type": {"readonly": True},
+    }
+
+    _attribute_map = {
+        "relevancy_score": {"key": "relevancyScore", "type": "float"},
+        "entity_resource_name": {"key": "entityResourceName", "type": "str"},
+        "highlights": {"key": "highlights", "type": "{[str]}"},
+        "usage": {"key": "usage", "type": "Usage"},
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "IndexAnnotations"},
+        "properties": {"key": "properties", "type": "IndexProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "long"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        relevancy_score: Optional[float] = None,
+        entity_resource_name: Optional[str] = None,
+        highlights: Optional[Dict[str, List[str]]] = None,
+        usage: Optional["Usage"] = None,
+        schema_id: Optional[str] = None,
+        entity_id: Optional[str] = None,
+        kind: Optional[Union[str, "EntityKind"]] = None,
+        annotations: Optional["IndexAnnotations"] = None,
+        properties: Optional["IndexProperties"] = None,
+        internal: Optional[Dict[str, Any]] = None,
+        update_sequence: Optional[int] = None,
+        type: Optional[str] = None,
+        relationships: Optional[List["Relationship"]] = None,
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword relevancy_score:
+        :paramtype relevancy_score: float
+        :keyword entity_resource_name:
+        :paramtype entity_resource_name: str
+        :keyword highlights: Dictionary of
+         <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>.
+        :paramtype highlights: dict[str, list[str]]
+        :keyword usage:
+        :paramtype usage: ~index_service_apis.models.Usage
+        :keyword schema_id:
+        :paramtype schema_id: str
+        :keyword entity_id:
+        :paramtype entity_id: str
+        :keyword kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.EntityKind
+        :keyword annotations:
+        :paramtype annotations: ~index_service_apis.models.IndexAnnotations
+        :keyword properties:
+        :paramtype properties: ~index_service_apis.models.IndexProperties
+        :keyword internal: Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence:
+        :paramtype update_sequence: long
+        :keyword type:
+        :paramtype type: str
+        :keyword relationships:
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(IndexEntityResponse, self).__init__(**kwargs)
+        self.relevancy_score = relevancy_score
+        self.entity_resource_name = entity_resource_name
+        self.highlights = highlights
+        self.usage = usage
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = None
+        self.entity_container_id = None
+        self.entity_object_id = None
+        self.resource_type = None
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class IndexProperties(msrest.serialization.Model):
+    """IndexProperties.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar updated_time:
+    :vartype updated_time: ~datetime.datetime
+    :ivar creation_context:
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "updated_time": {"key": "updatedTime", "type": "iso-8601"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(
+        self,
+        *,
+        additional_properties: Optional[Dict[str, Any]] = None,
+        updated_time: Optional[datetime.datetime] = None,
+        creation_context: Optional["CreationContext"] = None,
+        **kwargs
+    ):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword updated_time:
+        :paramtype updated_time: ~datetime.datetime
+        :keyword creation_context:
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(IndexProperties, self).__init__(**kwargs)
+        self.additional_properties = additional_properties
+        self.updated_time = updated_time
+        self.creation_context = creation_context
+
+
+class IndexResourceDiscoveryResponseItem(msrest.serialization.Model):
+    """IndexResourceDiscoveryResponseItem.
+
+    :ivar name:
+    :vartype name: str
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar resource_type:
+    :vartype resource_type: str
+    :ivar region:
+    :vartype region: str
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group_name:
+    :vartype resource_group_name: str
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    :ivar is_customer_managed:
+    :vartype is_customer_managed: bool
+    :ivar is_private_link_resource:
+    :vartype is_private_link_resource: bool
+    :ivar is_private_link_resource_behind_vnet:
+    :vartype is_private_link_resource_behind_vnet: bool
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "region": {"key": "region", "type": "str"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group_name": {"key": "resourceGroupName", "type": "str"},
+        "tags": {"key": "tags", "type": "{str}"},
+        "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"},
+        "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"},
+        "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"},
+    }
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = None,
+        resource_id: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        region: Optional[str] = None,
+        regions: Optional[List["ResourceRegion"]] = None,
+        subscription_id: Optional[str] = None,
+        resource_group_name: Optional[str] = None,
+        tags: Optional[Dict[str, str]] = None,
+        is_customer_managed: Optional[bool] = None,
+        is_private_link_resource: Optional[bool] = None,
+        is_private_link_resource_behind_vnet: Optional[bool] = None,
+        **kwargs
+    ):
+        """
+        :keyword name:
+        :paramtype name: str
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword resource_type:
+        :paramtype resource_type: str
+        :keyword region:
+        :paramtype region: str
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group_name:
+        :paramtype resource_group_name: str
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        :keyword is_customer_managed:
+        :paramtype is_customer_managed: bool
+        :keyword is_private_link_resource:
+        :paramtype is_private_link_resource: bool
+        :keyword is_private_link_resource_behind_vnet:
+        :paramtype is_private_link_resource_behind_vnet: bool
+        """
+        super(IndexResourceDiscoveryResponseItem, self).__init__(**kwargs)
+        self.name = name
+        self.resource_id = resource_id
+        self.resource_type = resource_type
+        self.region = region
+        self.regions = regions
+        self.subscription_id = subscription_id
+        self.resource_group_name = resource_group_name
+        self.tags = tags
+        self.is_customer_managed = is_customer_managed
+        self.is_private_link_resource = is_private_link_resource
+        self.is_private_link_resource_behind_vnet = is_private_link_resource_behind_vnet
+
+
+class IndexResourceDiscoveryResponseItemPaginatedResult(msrest.serialization.Model):
+    """IndexResourceDiscoveryResponseItemPaginatedResult.
+
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem]
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar next_link:
+    :vartype next_link: str
+    """
+
+    _attribute_map = {
+        "value": {"key": "value", "type": "[IndexResourceDiscoveryResponseItem]"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "next_link": {"key": "nextLink", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        value: Optional[List["IndexResourceDiscoveryResponseItem"]] = None,
+        continuation_token: Optional[str] = None,
+        next_link: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem]
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword next_link:
+        :paramtype next_link: str
+        """
+        super(IndexResourceDiscoveryResponseItemPaginatedResult, self).__init__(**kwargs)
+        self.value = value
+        self.continuation_token = continuation_token
+        self.next_link = next_link
+
+
+class InnerErrorResponse(msrest.serialization.Model):
+    """InnerErrorResponse.
+
+    :ivar code:
+    :vartype code: str
+    :ivar inner_error:
+    :vartype inner_error: ~index_service_apis.models.InnerErrorResponse
+    """
+
+    _attribute_map = {
+        "code": {"key": "code", "type": "str"},
+        "inner_error": {"key": "innerError", "type": "InnerErrorResponse"},
+    }
+
+    def __init__(self, *, code: Optional[str] = None, inner_error: Optional["InnerErrorResponse"] = None, **kwargs):
+        """
+        :keyword code:
+        :paramtype code: str
+        :keyword inner_error:
+        :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse
+        """
+        super(InnerErrorResponse, self).__init__(**kwargs)
+        self.code = code
+        self.inner_error = inner_error
+
+
+class InputNameAndDataTypeIdsList(msrest.serialization.Model):
+    """InputNameAndDataTypeIdsList.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar data_type_ids_list: Required.
+    :vartype data_type_ids_list: list[str]
+    :ivar is_optional: Required.
+    :vartype is_optional: bool
+    :ivar description: Required.
+    :vartype description: str
+    :ivar label: Required.
+    :vartype label: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "data_type_ids_list": {"required": True},
+        "is_optional": {"required": True},
+        "description": {"required": True},
+        "label": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "data_type_ids_list": {"key": "dataTypeIdsList", "type": "[str]"},
+        "is_optional": {"key": "isOptional", "type": "bool"},
+        "description": {"key": "description", "type": "str"},
+        "label": {"key": "label", "type": "str"},
+    }
+
+    def __init__(
+        self, *, name: str, data_type_ids_list: List[str], is_optional: bool, description: str, label: str, **kwargs
+    ):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword data_type_ids_list: Required.
+        :paramtype data_type_ids_list: list[str]
+        :keyword is_optional: Required.
+        :paramtype is_optional: bool
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword label: Required.
+        :paramtype label: str
+        """
+        super(InputNameAndDataTypeIdsList, self).__init__(**kwargs)
+        self.name = name
+        self.data_type_ids_list = data_type_ids_list
+        self.is_optional = is_optional
+        self.description = description
+        self.label = label
+
+
+class InternalUxPresenceWarmUpRequest(msrest.serialization.Model):
+    """InternalUxPresenceWarmUpRequest.
+
+    :ivar resources:
+    :vartype resources: list[~index_service_apis.models.UxPresenceResource]
+    :ivar source_ip:
+    :vartype source_ip: str
+    :ivar user_tenant_id:
+    :vartype user_tenant_id: str
+    :ivar user_object_id:
+    :vartype user_object_id: str
+    """
+
+    _attribute_map = {
+        "resources": {"key": "resources", "type": "[UxPresenceResource]"},
+        "source_ip": {"key": "sourceIp", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        resources: Optional[List["UxPresenceResource"]] = None,
+        source_ip: Optional[str] = None,
+        user_tenant_id: Optional[str] = None,
+        user_object_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword resources:
+        :paramtype resources: list[~index_service_apis.models.UxPresenceResource]
+        :keyword source_ip:
+        :paramtype source_ip: str
+        :keyword user_tenant_id:
+        :paramtype user_tenant_id: str
+        :keyword user_object_id:
+        :paramtype user_object_id: str
+        """
+        super(InternalUxPresenceWarmUpRequest, self).__init__(**kwargs)
+        self.resources = resources
+        self.source_ip = source_ip
+        self.user_tenant_id = user_tenant_id
+        self.user_object_id = user_object_id
+
+
+class JobCost(msrest.serialization.Model):
+    """JobCost.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar charged_cpu_core_seconds: Required.
+    :vartype charged_cpu_core_seconds: float
+    :ivar charged_cpu_memory_megabyte_seconds: Required.
+    :vartype charged_cpu_memory_megabyte_seconds: float
+    :ivar charged_gpu_seconds: Required.
+    :vartype charged_gpu_seconds: float
+    :ivar charged_node_utilization_seconds: Required.
+    :vartype charged_node_utilization_seconds: float
+    """
+
+    _validation = {
+        "charged_cpu_core_seconds": {"required": True},
+        "charged_cpu_memory_megabyte_seconds": {"required": True},
+        "charged_gpu_seconds": {"required": True},
+        "charged_node_utilization_seconds": {"required": True},
+    }
+
+    _attribute_map = {
+        "charged_cpu_core_seconds": {"key": "chargedCpuCoreSeconds", "type": "float"},
+        "charged_cpu_memory_megabyte_seconds": {"key": "chargedCpuMemoryMegabyteSeconds", "type": "float"},
+        "charged_gpu_seconds": {"key": "chargedGpuSeconds", "type": "float"},
+        "charged_node_utilization_seconds": {"key": "chargedNodeUtilizationSeconds", "type": "float"},
+    }
+
+    def __init__(
+        self,
+        *,
+        charged_cpu_core_seconds: float,
+        charged_cpu_memory_megabyte_seconds: float,
+        charged_gpu_seconds: float,
+        charged_node_utilization_seconds: float,
+        **kwargs
+    ):
+        """
+        :keyword charged_cpu_core_seconds: Required.
+        :paramtype charged_cpu_core_seconds: float
+        :keyword charged_cpu_memory_megabyte_seconds: Required.
+        :paramtype charged_cpu_memory_megabyte_seconds: float
+        :keyword charged_gpu_seconds: Required.
+        :paramtype charged_gpu_seconds: float
+        :keyword charged_node_utilization_seconds: Required.
+        :paramtype charged_node_utilization_seconds: float
+        """
+        super(JobCost, self).__init__(**kwargs)
+        self.charged_cpu_core_seconds = charged_cpu_core_seconds
+        self.charged_cpu_memory_megabyte_seconds = charged_cpu_memory_megabyte_seconds
+        self.charged_gpu_seconds = charged_gpu_seconds
+        self.charged_node_utilization_seconds = charged_node_utilization_seconds
+
+
+class MaterializationComputeResource(msrest.serialization.Model):
+    """MaterializationComputeResource.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar instance_type: Required.
+    :vartype instance_type: str
+    """
+
+    _validation = {
+        "instance_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "instance_type": {"key": "instanceType", "type": "str"},
+    }
+
+    def __init__(self, *, instance_type: str, **kwargs):
+        """
+        :keyword instance_type: Required.
+        :paramtype instance_type: str
+        """
+        super(MaterializationComputeResource, self).__init__(**kwargs)
+        self.instance_type = instance_type
+
+
+class MaterializationSettings(msrest.serialization.Model):
+    """MaterializationSettings.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar materialization_store_type: Required. Possible values include: "None", "Online",
+     "Offline", "OnlineAndOffline".
+    :vartype materialization_store_type: str or
+     ~index_service_apis.models.MaterializationSettingsMaterializationStoreType
+    :ivar schedule: Required.
+    :vartype schedule: ~index_service_apis.models.Recurrence
+    :ivar notification:
+    :vartype notification: ~index_service_apis.models.NotificationSetting
+    :ivar resource: Required.
+    :vartype resource: ~index_service_apis.models.MaterializationComputeResource
+    :ivar spark_configuration: Required. Dictionary of :code:`<string>`.
+    :vartype spark_configuration: dict[str, str]
+    """
+
+    _validation = {
+        "materialization_store_type": {"required": True},
+        "schedule": {"required": True},
+        "resource": {"required": True},
+        "spark_configuration": {"required": True},
+    }
+
+    _attribute_map = {
+        "materialization_store_type": {"key": "materializationStoreType", "type": "str"},
+        "schedule": {"key": "schedule", "type": "Recurrence"},
+        "notification": {"key": "notification", "type": "NotificationSetting"},
+        "resource": {"key": "resource", "type": "MaterializationComputeResource"},
+        "spark_configuration": {"key": "sparkConfiguration", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        materialization_store_type: Union[str, "MaterializationSettingsMaterializationStoreType"],
+        schedule: "Recurrence",
+        resource: "MaterializationComputeResource",
+        spark_configuration: Dict[str, str],
+        notification: Optional["NotificationSetting"] = None,
+        **kwargs
+    ):
+        """
+        :keyword materialization_store_type: Required. Possible values include: "None", "Online",
+         "Offline", "OnlineAndOffline".
+        :paramtype materialization_store_type: str or
+         ~index_service_apis.models.MaterializationSettingsMaterializationStoreType
+        :keyword schedule: Required.
+        :paramtype schedule: ~index_service_apis.models.Recurrence
+        :keyword notification:
+        :paramtype notification: ~index_service_apis.models.NotificationSetting
+        :keyword resource: Required.
+        :paramtype resource: ~index_service_apis.models.MaterializationComputeResource
+        :keyword spark_configuration: Required. Dictionary of :code:`<string>`.
+        :paramtype spark_configuration: dict[str, str]
+        """
+        super(MaterializationSettings, self).__init__(**kwargs)
+        self.materialization_store_type = materialization_store_type
+        self.schedule = schedule
+        self.notification = notification
+        self.resource = resource
+        self.spark_configuration = spark_configuration
+
+
+class ModelAnnotations(msrest.serialization.Model):
+    """ModelAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar datasets: Required.
+    :vartype datasets: list[~index_service_apis.models.DatasetReference]
+    :ivar sample_input_data: Required.
+    :vartype sample_input_data: str
+    :ivar sample_output_data: Required.
+    :vartype sample_output_data: str
+    :ivar resource_requirements: Required.
+    :vartype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "datasets": {"required": True},
+        "sample_input_data": {"required": True},
+        "sample_output_data": {"required": True},
+        "resource_requirements": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "datasets": {"key": "datasets", "type": "[DatasetReference]"},
+        "sample_input_data": {"key": "sampleInputData", "type": "str"},
+        "sample_output_data": {"key": "sampleOutputData", "type": "str"},
+        "resource_requirements": {"key": "resourceRequirements", "type": "ContainerResourceRequirements"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        datasets: List["DatasetReference"],
+        sample_input_data: str,
+        sample_output_data: str,
+        resource_requirements: "ContainerResourceRequirements",
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword datasets: Required.
+        :paramtype datasets: list[~index_service_apis.models.DatasetReference]
+        :keyword sample_input_data: Required.
+        :paramtype sample_input_data: str
+        :keyword sample_output_data: Required.
+        :paramtype sample_output_data: str
+        :keyword resource_requirements: Required.
+        :paramtype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(ModelAnnotations, self).__init__(**kwargs)
+        self.datasets = datasets
+        self.sample_input_data = sample_input_data
+        self.sample_output_data = sample_output_data
+        self.resource_requirements = resource_requirements
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class ModelProperties(msrest.serialization.Model):
+    """ModelProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar model_framework: Required.
+    :vartype model_framework: str
+    :ivar model_framework_version: Required.
+    :vartype model_framework_version: str
+    :ivar model_format: Required.
+    :vartype model_format: str
+    :ivar version: Required.
+    :vartype version: int
+    :ivar alphanumeric_version: Required.
+    :vartype alphanumeric_version: str
+    :ivar url: Required.
+    :vartype url: str
+    :ivar mime_type: Required.
+    :vartype mime_type: str
+    :ivar modified_time: Required.
+    :vartype modified_time: ~datetime.datetime
+    :ivar unpack: Required.
+    :vartype unpack: bool
+    :ivar parent_model_id: Required.
+    :vartype parent_model_id: str
+    :ivar run_id: Required.
+    :vartype run_id: str
+    :ivar experiment_name: Required.
+    :vartype experiment_name: str
+    :ivar experiment_id: Required.
+    :vartype experiment_id: str
+    :ivar derived_model_ids: Required.
+    :vartype derived_model_ids: list[str]
+    :ivar user_properties: Required. Dictionary of :code:`<string>`.
+    :vartype user_properties: dict[str, str]
+    :ivar is_anonymous: Required.
+    :vartype is_anonymous: bool
+    :ivar orgin_asset_id: Required.
+    :vartype orgin_asset_id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "name": {"required": True},
+        "model_framework": {"required": True},
+        "model_framework_version": {"required": True},
+        "model_format": {"required": True},
+        "version": {"required": True},
+        "alphanumeric_version": {"required": True},
+        "url": {"required": True},
+        "mime_type": {"required": True},
+        "modified_time": {"required": True},
+        "unpack": {"required": True},
+        "parent_model_id": {"required": True},
+        "run_id": {"required": True},
+        "experiment_name": {"required": True},
+        "experiment_id": {"required": True},
+        "derived_model_ids": {"required": True},
+        "user_properties": {"required": True},
+        "is_anonymous": {"required": True},
+        "orgin_asset_id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "model_framework": {"key": "modelFramework", "type": "str"},
+        "model_framework_version": {"key": "modelFrameworkVersion", "type": "str"},
+        "model_format": {"key": "modelFormat", "type": "str"},
+        "version": {"key": "version", "type": "int"},
+        "alphanumeric_version": {"key": "alphanumericVersion", "type": "str"},
+        "url": {"key": "url", "type": "str"},
+        "mime_type": {"key": "mimeType", "type": "str"},
+        "modified_time": {"key": "modifiedTime", "type": "iso-8601"},
+        "unpack": {"key": "unpack", "type": "bool"},
+        "parent_model_id": {"key": "parentModelId", "type": "str"},
+        "run_id": {"key": "runId", "type": "str"},
+        "experiment_name": {"key": "experimentName", "type": "str"},
+        "experiment_id": {"key": "experimentId", "type": "str"},
+        "derived_model_ids": {"key": "derivedModelIds", "type": "[str]"},
+        "user_properties": {"key": "userProperties", "type": "{str}"},
+        "is_anonymous": {"key": "isAnonymous", "type": "bool"},
+        "orgin_asset_id": {"key": "orginAssetId", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        name: str,
+        model_framework: str,
+        model_framework_version: str,
+        model_format: str,
+        version: int,
+        alphanumeric_version: str,
+        url: str,
+        mime_type: str,
+        modified_time: datetime.datetime,
+        unpack: bool,
+        parent_model_id: str,
+        run_id: str,
+        experiment_name: str,
+        experiment_id: str,
+        derived_model_ids: List[str],
+        user_properties: Dict[str, str],
+        is_anonymous: bool,
+        orgin_asset_id: str,
+        creation_context: "CreationContext",
+        **kwargs
+    ):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword model_framework: Required.
+        :paramtype model_framework: str
+        :keyword model_framework_version: Required.
+        :paramtype model_framework_version: str
+        :keyword model_format: Required.
+        :paramtype model_format: str
+        :keyword version: Required.
+        :paramtype version: int
+        :keyword alphanumeric_version: Required.
+        :paramtype alphanumeric_version: str
+        :keyword url: Required.
+        :paramtype url: str
+        :keyword mime_type: Required.
+        :paramtype mime_type: str
+        :keyword modified_time: Required.
+        :paramtype modified_time: ~datetime.datetime
+        :keyword unpack: Required.
+        :paramtype unpack: bool
+        :keyword parent_model_id: Required.
+        :paramtype parent_model_id: str
+        :keyword run_id: Required.
+        :paramtype run_id: str
+        :keyword experiment_name: Required.
+        :paramtype experiment_name: str
+        :keyword experiment_id: Required.
+        :paramtype experiment_id: str
+        :keyword derived_model_ids: Required.
+        :paramtype derived_model_ids: list[str]
+        :keyword user_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype user_properties: dict[str, str]
+        :keyword is_anonymous: Required.
+        :paramtype is_anonymous: bool
+        :keyword orgin_asset_id: Required.
+        :paramtype orgin_asset_id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(ModelProperties, self).__init__(**kwargs)
+        self.id = id
+        self.name = name
+        self.model_framework = model_framework
+        self.model_framework_version = model_framework_version
+        self.model_format = model_format
+        self.version = version
+        self.alphanumeric_version = alphanumeric_version
+        self.url = url
+        self.mime_type = mime_type
+        self.modified_time = modified_time
+        self.unpack = unpack
+        self.parent_model_id = parent_model_id
+        self.run_id = run_id
+        self.experiment_name = experiment_name
+        self.experiment_id = experiment_id
+        self.derived_model_ids = derived_model_ids
+        self.user_properties = user_properties
+        self.is_anonymous = is_anonymous
+        self.orgin_asset_id = orgin_asset_id
+        self.creation_context = creation_context
+
+
+class ModelsVersionedEntitiesResponse(msrest.serialization.Model):
+    """ModelsVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.ModelsVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[ModelsVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["ModelsVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.ModelsVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(ModelsVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class ModelsVersionedEntity(msrest.serialization.Model):
+    """ModelsVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.ModelAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.ModelProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "ModelAnnotations"},
+        "properties": {"key": "properties", "type": "ModelProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "ModelsVersionedEntityKind"],
+        annotations: "ModelAnnotations",
+        properties: "ModelProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.ModelAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.ModelProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(ModelsVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class ModuleAnnotations(msrest.serialization.Model):
+    """ModuleAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar module_name: Required.
+    :vartype module_name: str
+    :ivar display_name: Required.
+    :vartype display_name: str
+    :ivar lower_name: Required.
+    :vartype lower_name: str
+    :ivar module_version: Required.
+    :vartype module_version: str
+    :ivar inputs: Required.
+    :vartype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList]
+    :ivar outputs: Required.
+    :vartype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId]
+    :ivar category: Required.
+    :vartype category: str
+    :ivar step_type: Required.
+    :vartype step_type: str
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus
+    :ivar is_deterministic: Required.
+    :vartype is_deterministic: bool
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar component_type_version: Required.
+    :vartype component_type_version: str
+    :ivar snapshot_id: Required.
+    :vartype snapshot_id: str
+    :ivar runconfig: Required.
+    :vartype runconfig: str
+    :ivar control_outputs: Required.
+    :vartype control_outputs: list[~index_service_apis.models.ControlOutput]
+    :ivar parameters: Required.
+    :vartype parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+    :ivar metadata_parameters: Required.
+    :vartype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+    :ivar aml_module_name: Required.
+    :vartype aml_module_name: str
+    :ivar aml_module_entity_status: Required. Possible values include: "Active", "Deprecated",
+     "Disabled".
+    :vartype aml_module_entity_status: str or
+     ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus
+    :ivar module_type: Required. Possible values include: "User", "Builtin".
+    :vartype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType
+    :ivar module_execution_type: Required.
+    :vartype module_execution_type: str
+    :ivar arguments_serialized: Required.
+    :vartype arguments_serialized: str
+    :ivar cloud_settings_serialized: Required.
+    :vartype cloud_settings_serialized: str
+    :ivar stage: Required.
+    :vartype stage: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "module_name": {"required": True},
+        "display_name": {"required": True},
+        "lower_name": {"required": True},
+        "module_version": {"required": True},
+        "inputs": {"required": True},
+        "outputs": {"required": True},
+        "category": {"required": True},
+        "step_type": {"required": True},
+        "entity_status": {"required": True},
+        "is_deterministic": {"required": True},
+        "kv_tags": {"required": True},
+        "properties": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "component_type_version": {"required": True},
+        "snapshot_id": {"required": True},
+        "runconfig": {"required": True},
+        "control_outputs": {"required": True},
+        "parameters": {"required": True},
+        "metadata_parameters": {"required": True},
+        "aml_module_name": {"required": True},
+        "aml_module_entity_status": {"required": True},
+        "module_type": {"required": True},
+        "module_execution_type": {"required": True},
+        "arguments_serialized": {"required": True},
+        "cloud_settings_serialized": {"required": True},
+        "stage": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "module_name": {"key": "moduleName", "type": "str"},
+        "display_name": {"key": "displayName", "type": "str"},
+        "lower_name": {"key": "lowerName", "type": "str"},
+        "module_version": {"key": "moduleVersion", "type": "str"},
+        "inputs": {"key": "inputs", "type": "[InputNameAndDataTypeIdsList]"},
+        "outputs": {"key": "outputs", "type": "[OutputNameAndDataTypeId]"},
+        "category": {"key": "category", "type": "str"},
+        "step_type": {"key": "stepType", "type": "str"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "is_deterministic": {"key": "isDeterministic", "type": "bool"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "component_type_version": {"key": "componentTypeVersion", "type": "str"},
+        "snapshot_id": {"key": "snapshotId", "type": "str"},
+        "runconfig": {"key": "runconfig", "type": "str"},
+        "control_outputs": {"key": "controlOutputs", "type": "[ControlOutput]"},
+        "parameters": {"key": "parameters", "type": "[StructuredInterfaceParameter]"},
+        "metadata_parameters": {"key": "metadataParameters", "type": "[StructuredInterfaceParameter]"},
+        "aml_module_name": {"key": "amlModuleName", "type": "str"},
+        "aml_module_entity_status": {"key": "amlModuleEntityStatus", "type": "str"},
+        "module_type": {"key": "moduleType", "type": "str"},
+        "module_execution_type": {"key": "moduleExecutionType", "type": "str"},
+        "arguments_serialized": {"key": "argumentsSerialized", "type": "str"},
+        "cloud_settings_serialized": {"key": "cloudSettingsSerialized", "type": "str"},
+        "stage": {"key": "stage", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        module_name: str,
+        display_name: str,
+        lower_name: str,
+        module_version: str,
+        inputs: List["InputNameAndDataTypeIdsList"],
+        outputs: List["OutputNameAndDataTypeId"],
+        category: str,
+        step_type: str,
+        entity_status: Union[str, "ModuleAnnotationsEntityStatus"],
+        is_deterministic: bool,
+        kv_tags: Dict[str, str],
+        properties: Dict[str, str],
+        last_modified_date: datetime.datetime,
+        last_updated_by: "CreatedBy",
+        component_type_version: str,
+        snapshot_id: str,
+        runconfig: str,
+        control_outputs: List["ControlOutput"],
+        parameters: List["StructuredInterfaceParameter"],
+        metadata_parameters: List["StructuredInterfaceParameter"],
+        aml_module_name: str,
+        aml_module_entity_status: Union[str, "ModuleAnnotationsAmlModuleEntityStatus"],
+        module_type: Union[str, "ModuleAnnotationsModuleType"],
+        module_execution_type: str,
+        arguments_serialized: str,
+        cloud_settings_serialized: str,
+        stage: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword module_name: Required.
+        :paramtype module_name: str
+        :keyword display_name: Required.
+        :paramtype display_name: str
+        :keyword lower_name: Required.
+        :paramtype lower_name: str
+        :keyword module_version: Required.
+        :paramtype module_version: str
+        :keyword inputs: Required.
+        :paramtype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList]
+        :keyword outputs: Required.
+        :paramtype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId]
+        :keyword category: Required.
+        :paramtype category: str
+        :keyword step_type: Required.
+        :paramtype step_type: str
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus
+        :keyword is_deterministic: Required.
+        :paramtype is_deterministic: bool
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword component_type_version: Required.
+        :paramtype component_type_version: str
+        :keyword snapshot_id: Required.
+        :paramtype snapshot_id: str
+        :keyword runconfig: Required.
+        :paramtype runconfig: str
+        :keyword control_outputs: Required.
+        :paramtype control_outputs: list[~index_service_apis.models.ControlOutput]
+        :keyword parameters: Required.
+        :paramtype parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+        :keyword metadata_parameters: Required.
+        :paramtype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter]
+        :keyword aml_module_name: Required.
+        :paramtype aml_module_name: str
+        :keyword aml_module_entity_status: Required. Possible values include: "Active", "Deprecated",
+         "Disabled".
+        :paramtype aml_module_entity_status: str or
+         ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus
+        :keyword module_type: Required. Possible values include: "User", "Builtin".
+        :paramtype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType
+        :keyword module_execution_type: Required.
+        :paramtype module_execution_type: str
+        :keyword arguments_serialized: Required.
+        :paramtype arguments_serialized: str
+        :keyword cloud_settings_serialized: Required.
+        :paramtype cloud_settings_serialized: str
+        :keyword stage: Required.
+        :paramtype stage: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(ModuleAnnotations, self).__init__(**kwargs)
+        self.module_name = module_name
+        self.display_name = display_name
+        self.lower_name = lower_name
+        self.module_version = module_version
+        self.inputs = inputs
+        self.outputs = outputs
+        self.category = category
+        self.step_type = step_type
+        self.entity_status = entity_status
+        self.is_deterministic = is_deterministic
+        self.kv_tags = kv_tags
+        self.properties = properties
+        self.last_modified_date = last_modified_date
+        self.last_updated_by = last_updated_by
+        self.component_type_version = component_type_version
+        self.snapshot_id = snapshot_id
+        self.runconfig = runconfig
+        self.control_outputs = control_outputs
+        self.parameters = parameters
+        self.metadata_parameters = metadata_parameters
+        self.aml_module_name = aml_module_name
+        self.aml_module_entity_status = aml_module_entity_status
+        self.module_type = module_type
+        self.module_execution_type = module_execution_type
+        self.arguments_serialized = arguments_serialized
+        self.cloud_settings_serialized = cloud_settings_serialized
+        self.stage = stage
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class ModuleProperties(msrest.serialization.Model):
+    """ModuleProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar aml_module_id: Required.
+    :vartype aml_module_id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "aml_module_id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "aml_module_id": {"key": "amlModuleId", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, id: str, aml_module_id: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword aml_module_id: Required.
+        :paramtype aml_module_id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(ModuleProperties, self).__init__(**kwargs)
+        self.id = id
+        self.aml_module_id = aml_module_id
+        self.creation_context = creation_context
+
+
+class ModulesVersionedEntitiesResponse(msrest.serialization.Model):
+    """ModulesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.ModulesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[ModulesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["ModulesVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.ModulesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(ModulesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class ModulesVersionedEntity(msrest.serialization.Model):
+    """ModulesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.ModuleAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.ModuleProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "ModuleAnnotations"},
+        "properties": {"key": "properties", "type": "ModuleProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "ModulesVersionedEntityKind"],
+        annotations: "ModuleAnnotations",
+        properties: "ModuleProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.ModuleAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.ModuleProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(ModulesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class NotificationSetting(msrest.serialization.Model):
+    """NotificationSetting.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar emails: Required.
+    :vartype emails: list[str]
+    :ivar email_on: Required.
+    :vartype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem]
+    :ivar webhooks: Required. Dictionary of :code:`<Webhook>`.
+    :vartype webhooks: dict[str, ~index_service_apis.models.Webhook]
+    """
+
+    _validation = {
+        "emails": {"required": True},
+        "email_on": {"required": True},
+        "webhooks": {"required": True},
+    }
+
+    _attribute_map = {
+        "emails": {"key": "emails", "type": "[str]"},
+        "email_on": {"key": "emailOn", "type": "[str]"},
+        "webhooks": {"key": "webhooks", "type": "{Webhook}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        emails: List[str],
+        email_on: List[Union[str, "NotificationSettingEmailOnItem"]],
+        webhooks: Dict[str, "Webhook"],
+        **kwargs
+    ):
+        """
+        :keyword emails: Required.
+        :paramtype emails: list[str]
+        :keyword email_on: Required.
+        :paramtype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem]
+        :keyword webhooks: Required. Dictionary of :code:`<Webhook>`.
+        :paramtype webhooks: dict[str, ~index_service_apis.models.Webhook]
+        """
+        super(NotificationSetting, self).__init__(**kwargs)
+        self.emails = emails
+        self.email_on = email_on
+        self.webhooks = webhooks
+
+
+class OnlineEndpointAnnotations(msrest.serialization.Model):
+    """OnlineEndpointAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar compute_type: Required.
+    :vartype compute_type: str
+    :ivar compute_target: Required.
+    :vartype compute_target: ~index_service_apis.models.EndpointComputeTarget
+    :ivar scoring_uri: Required.
+    :vartype scoring_uri: str
+    :ivar location: Required.
+    :vartype location: str
+    :ivar last_modified_time: Required.
+    :vartype last_modified_time: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "compute_type": {"required": True},
+        "compute_target": {"required": True},
+        "scoring_uri": {"required": True},
+        "location": {"required": True},
+        "last_modified_time": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "compute_type": {"key": "computeType", "type": "str"},
+        "compute_target": {"key": "computeTarget", "type": "EndpointComputeTarget"},
+        "scoring_uri": {"key": "scoringUri", "type": "str"},
+        "location": {"key": "location", "type": "str"},
+        "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        compute_type: str,
+        compute_target: "EndpointComputeTarget",
+        scoring_uri: str,
+        location: str,
+        last_modified_time: datetime.datetime,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword compute_type: Required.
+        :paramtype compute_type: str
+        :keyword compute_target: Required.
+        :paramtype compute_target: ~index_service_apis.models.EndpointComputeTarget
+        :keyword scoring_uri: Required.
+        :paramtype scoring_uri: str
+        :keyword location: Required.
+        :paramtype location: str
+        :keyword last_modified_time: Required.
+        :paramtype last_modified_time: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(OnlineEndpointAnnotations, self).__init__(**kwargs)
+        self.compute_type = compute_type
+        self.compute_target = compute_target
+        self.scoring_uri = scoring_uri
+        self.location = location
+        self.last_modified_time = last_modified_time
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class OnlineEndpointProperties(msrest.serialization.Model):
+    """OnlineEndpointProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "properties": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "properties": {"key": "properties", "type": "{str}"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, properties: Dict[str, str], creation_context: "CreationContext", **kwargs):
+        """
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(OnlineEndpointProperties, self).__init__(**kwargs)
+        self.properties = properties
+        self.creation_context = creation_context
+
+
+class OnlineendpointsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """OnlineendpointsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[OnlineendpointsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["OnlineendpointsUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(OnlineendpointsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class OnlineendpointsUnversionedEntity(msrest.serialization.Model):
+    """OnlineendpointsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.OnlineEndpointAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.OnlineEndpointProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "OnlineEndpointAnnotations"},
+        "properties": {"key": "properties", "type": "OnlineEndpointProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "OnlineendpointsUnversionedEntityKind"],
+        annotations: "OnlineEndpointAnnotations",
+        properties: "OnlineEndpointProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.OnlineEndpointAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.OnlineEndpointProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(OnlineendpointsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class OutputNameAndDataTypeId(msrest.serialization.Model):
+    """OutputNameAndDataTypeId.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar data_type_id: Required.
+    :vartype data_type_id: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar label: Required.
+    :vartype label: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "data_type_id": {"required": True},
+        "description": {"required": True},
+        "label": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "data_type_id": {"key": "dataTypeId", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "label": {"key": "label", "type": "str"},
+    }
+
+    def __init__(self, *, name: str, data_type_id: str, description: str, label: str, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword data_type_id: Required.
+        :paramtype data_type_id: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword label: Required.
+        :paramtype label: str
+        """
+        super(OutputNameAndDataTypeId, self).__init__(**kwargs)
+        self.name = name
+        self.data_type_id = data_type_id
+        self.description = description
+        self.label = label
+
+
+class PipelineAnnotations(msrest.serialization.Model):
+    """PipelineAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar pipeline_name: Required.
+    :vartype pipeline_name: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar url: Required.
+    :vartype url: str
+    :ivar pipeline_endpoint_ids: Required.
+    :vartype pipeline_endpoint_ids: list[str]
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar last_updated_by: Required.
+    :vartype last_updated_by: ~index_service_apis.models.CreatedBy
+    :ivar last_run_id: Required.
+    :vartype last_run_id: str
+    :ivar pipeline_type: Required.
+    :vartype pipeline_type: str
+    :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+     "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+    :vartype last_run_status_code: str or
+     ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode
+    :ivar last_run_creation_time: Required.
+    :vartype last_run_creation_time: ~datetime.datetime
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "pipeline_name": {"required": True},
+        "version": {"required": True},
+        "url": {"required": True},
+        "pipeline_endpoint_ids": {"required": True},
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "last_updated_by": {"required": True},
+        "last_run_id": {"required": True},
+        "pipeline_type": {"required": True},
+        "last_run_status_code": {"required": True},
+        "last_run_creation_time": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "pipeline_name": {"key": "pipelineName", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "url": {"key": "url", "type": "str"},
+        "pipeline_endpoint_ids": {"key": "pipelineEndpointIds", "type": "[str]"},
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"},
+        "last_run_id": {"key": "lastRunId", "type": "str"},
+        "pipeline_type": {"key": "pipelineType", "type": "str"},
+        "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"},
+        "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        pipeline_name: str,
+        version: str,
+        url: str,
+        pipeline_endpoint_ids: List[str],
+        kv_tags: Dict[str, str],
+        step_tags: Dict[str, str],
+        properties: Dict[str, str],
+        step_properties: Dict[str, str],
+        entity_status: Union[str, "PipelineAnnotationsEntityStatus"],
+        last_modified_date: datetime.datetime,
+        last_updated_by: "CreatedBy",
+        last_run_id: str,
+        pipeline_type: str,
+        last_run_status_code: Union[str, "PipelineAnnotationsLastRunStatusCode"],
+        last_run_creation_time: datetime.datetime,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword pipeline_name: Required.
+        :paramtype pipeline_name: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword url: Required.
+        :paramtype url: str
+        :keyword pipeline_endpoint_ids: Required.
+        :paramtype pipeline_endpoint_ids: list[str]
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword last_updated_by: Required.
+        :paramtype last_updated_by: ~index_service_apis.models.CreatedBy
+        :keyword last_run_id: Required.
+        :paramtype last_run_id: str
+        :keyword pipeline_type: Required.
+        :paramtype pipeline_type: str
+        :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running",
+         "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested".
+        :paramtype last_run_status_code: str or
+         ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode
+        :keyword last_run_creation_time: Required.
+        :paramtype last_run_creation_time: ~datetime.datetime
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(PipelineAnnotations, self).__init__(**kwargs)
+        self.pipeline_name = pipeline_name
+        self.version = version
+        self.url = url
+        self.pipeline_endpoint_ids = pipeline_endpoint_ids
+        self.kv_tags = kv_tags
+        self.step_tags = step_tags
+        self.properties = properties
+        self.step_properties = step_properties
+        self.entity_status = entity_status
+        self.last_modified_date = last_modified_date
+        self.last_updated_by = last_updated_by
+        self.last_run_id = last_run_id
+        self.pipeline_type = pipeline_type
+        self.last_run_status_code = last_run_status_code
+        self.last_run_creation_time = last_run_creation_time
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class PipelineDraftAnnotations(msrest.serialization.Model):
+    """PipelineDraftAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar pipeline_type: Required.
+    :vartype pipeline_type: str
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "last_modified_date": {"required": True},
+        "pipeline_type": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "pipeline_type": {"key": "pipelineType", "type": "str"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        kv_tags: Dict[str, str],
+        step_tags: Dict[str, str],
+        properties: Dict[str, str],
+        step_properties: Dict[str, str],
+        entity_status: Union[str, "PipelineDraftAnnotationsEntityStatus"],
+        last_modified_date: datetime.datetime,
+        pipeline_type: str,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or
+         ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword pipeline_type: Required.
+        :paramtype pipeline_type: str
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(PipelineDraftAnnotations, self).__init__(**kwargs)
+        self.kv_tags = kv_tags
+        self.step_tags = step_tags
+        self.properties = properties
+        self.step_properties = step_properties
+        self.entity_status = entity_status
+        self.last_modified_date = last_modified_date
+        self.pipeline_type = pipeline_type
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class PipelineDraftProperties(msrest.serialization.Model):
+    """PipelineDraftProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(PipelineDraftProperties, self).__init__(**kwargs)
+        self.id = id
+        self.creation_context = creation_context
+
+
+class PipelinedraftsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """PipelinedraftsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[PipelinedraftsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["PipelinedraftsUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(PipelinedraftsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class PipelinedraftsUnversionedEntity(msrest.serialization.Model):
+    """PipelinedraftsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.PipelineDraftAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.PipelineDraftProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "PipelineDraftAnnotations"},
+        "properties": {"key": "properties", "type": "PipelineDraftProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "PipelinedraftsUnversionedEntityKind"],
+        annotations: "PipelineDraftAnnotations",
+        properties: "PipelineDraftProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.PipelineDraftAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.PipelineDraftProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(PipelinedraftsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class PipelineProperties(msrest.serialization.Model):
+    """PipelineProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(PipelineProperties, self).__init__(**kwargs)
+        self.id = id
+        self.creation_context = creation_context
+
+
+class PipelineRunAnnotations(msrest.serialization.Model):
+    """PipelineRunAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar kv_tags: Required. Dictionary of :code:`<string>`.
+    :vartype kv_tags: dict[str, str]
+    :ivar step_tags: Required. Dictionary of :code:`<string>`.
+    :vartype step_tags: dict[str, str]
+    :ivar properties: Required. Dictionary of :code:`<string>`.
+    :vartype properties: dict[str, str]
+    :ivar step_properties: Required. Dictionary of :code:`<string>`.
+    :vartype step_properties: dict[str, str]
+    :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+    :vartype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus
+    :ivar status: Required.
+    :vartype status: ~index_service_apis.models.ExperimentStatus
+    :ivar run_history_experiment_name: Required.
+    :vartype run_history_experiment_name: str
+    :ivar has_errors: Required.
+    :vartype has_errors: bool
+    :ivar has_warnings: Required.
+    :vartype has_warnings: bool
+    :ivar last_modified_date: Required.
+    :vartype last_modified_date: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "kv_tags": {"required": True},
+        "step_tags": {"required": True},
+        "properties": {"required": True},
+        "step_properties": {"required": True},
+        "entity_status": {"required": True},
+        "status": {"required": True},
+        "run_history_experiment_name": {"required": True},
+        "has_errors": {"required": True},
+        "has_warnings": {"required": True},
+        "last_modified_date": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "kv_tags": {"key": "kvTags", "type": "{str}"},
+        "step_tags": {"key": "stepTags", "type": "{str}"},
+        "properties": {"key": "properties", "type": "{str}"},
+        "step_properties": {"key": "stepProperties", "type": "{str}"},
+        "entity_status": {"key": "entityStatus", "type": "str"},
+        "status": {"key": "status", "type": "ExperimentStatus"},
+        "run_history_experiment_name": {"key": "runHistoryExperimentName", "type": "str"},
+        "has_errors": {"key": "hasErrors", "type": "bool"},
+        "has_warnings": {"key": "hasWarnings", "type": "bool"},
+        "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        kv_tags: Dict[str, str],
+        step_tags: Dict[str, str],
+        properties: Dict[str, str],
+        step_properties: Dict[str, str],
+        entity_status: Union[str, "PipelineRunAnnotationsEntityStatus"],
+        status: "ExperimentStatus",
+        run_history_experiment_name: str,
+        has_errors: bool,
+        has_warnings: bool,
+        last_modified_date: datetime.datetime,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword kv_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype kv_tags: dict[str, str]
+        :keyword step_tags: Required. Dictionary of :code:`<string>`.
+        :paramtype step_tags: dict[str, str]
+        :keyword properties: Required. Dictionary of :code:`<string>`.
+        :paramtype properties: dict[str, str]
+        :keyword step_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype step_properties: dict[str, str]
+        :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled".
+        :paramtype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus
+        :keyword status: Required.
+        :paramtype status: ~index_service_apis.models.ExperimentStatus
+        :keyword run_history_experiment_name: Required.
+        :paramtype run_history_experiment_name: str
+        :keyword has_errors: Required.
+        :paramtype has_errors: bool
+        :keyword has_warnings: Required.
+        :paramtype has_warnings: bool
+        :keyword last_modified_date: Required.
+        :paramtype last_modified_date: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(PipelineRunAnnotations, self).__init__(**kwargs)
+        self.kv_tags = kv_tags
+        self.step_tags = step_tags
+        self.properties = properties
+        self.step_properties = step_properties
+        self.entity_status = entity_status
+        self.status = status
+        self.run_history_experiment_name = run_history_experiment_name
+        self.has_errors = has_errors
+        self.has_warnings = has_warnings
+        self.last_modified_date = last_modified_date
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class PipelineRunProperties(msrest.serialization.Model):
+    """PipelineRunProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar id: Required.
+    :vartype id: str
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "id": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "id": {"key": "id", "type": "str"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs):
+        """
+        :keyword id: Required.
+        :paramtype id: str
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(PipelineRunProperties, self).__init__(**kwargs)
+        self.id = id
+        self.creation_context = creation_context
+
+
+class PipelinerunsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """PipelinerunsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[PipelinerunsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["PipelinerunsUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(PipelinerunsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class PipelinerunsUnversionedEntity(msrest.serialization.Model):
+    """PipelinerunsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.PipelineRunAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.PipelineRunProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "PipelineRunAnnotations"},
+        "properties": {"key": "properties", "type": "PipelineRunProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "PipelinerunsUnversionedEntityKind"],
+        annotations: "PipelineRunAnnotations",
+        properties: "PipelineRunProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        relationships: List["Relationship"],
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.PipelineRunAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.PipelineRunProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        """
+        super(PipelinerunsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.relationships = relationships
+
+
+class PipelinesVersionedEntitiesResponse(msrest.serialization.Model):
+    """PipelinesVersionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.PipelinesVersionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[PipelinesVersionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["PipelinesVersionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.PipelinesVersionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(PipelinesVersionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class PipelinesVersionedEntity(msrest.serialization.Model):
+    """PipelinesVersionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.PipelineAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.PipelineProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "PipelineAnnotations"},
+        "properties": {"key": "properties", "type": "PipelineProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "PipelinesVersionedEntityKind"],
+        annotations: "PipelineAnnotations",
+        properties: "PipelineProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.PipelineAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.PipelineProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(PipelinesVersionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class Purpose(msrest.serialization.Model):
+    """Purpose.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar has_inferencing_support: Required.
+    :vartype has_inferencing_support: bool
+    :ivar has_training_support: Required.
+    :vartype has_training_support: bool
+    """
+
+    _validation = {
+        "has_inferencing_support": {"required": True},
+        "has_training_support": {"required": True},
+    }
+
+    _attribute_map = {
+        "has_inferencing_support": {"key": "hasInferencingSupport", "type": "bool"},
+        "has_training_support": {"key": "hasTrainingSupport", "type": "bool"},
+    }
+
+    def __init__(self, *, has_inferencing_support: bool, has_training_support: bool, **kwargs):
+        """
+        :keyword has_inferencing_support: Required.
+        :paramtype has_inferencing_support: bool
+        :keyword has_training_support: Required.
+        :paramtype has_training_support: bool
+        """
+        super(Purpose, self).__init__(**kwargs)
+        self.has_inferencing_support = has_inferencing_support
+        self.has_training_support = has_training_support
+
+
+class Recurrence(msrest.serialization.Model):
+    """Recurrence.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar frequency: Required. Possible values include: "Month", "Week", "Day", "Hour", "Minute".
+    :vartype frequency: str or ~index_service_apis.models.RecurrenceFrequency
+    :ivar interval: Required.
+    :vartype interval: int
+    :ivar schedule: Required.
+    :vartype schedule: ~index_service_apis.models.RecurrenceSchedule
+    :ivar end_time: Required.
+    :vartype end_time: str
+    :ivar start_time: Required.
+    :vartype start_time: str
+    :ivar time_zone: Required.
+    :vartype time_zone: str
+    """
+
+    _validation = {
+        "frequency": {"required": True},
+        "interval": {"required": True},
+        "schedule": {"required": True},
+        "end_time": {"required": True},
+        "start_time": {"required": True},
+        "time_zone": {"required": True},
+    }
+
+    _attribute_map = {
+        "frequency": {"key": "frequency", "type": "str"},
+        "interval": {"key": "interval", "type": "int"},
+        "schedule": {"key": "schedule", "type": "RecurrenceSchedule"},
+        "end_time": {"key": "endTime", "type": "str"},
+        "start_time": {"key": "startTime", "type": "str"},
+        "time_zone": {"key": "timeZone", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        frequency: Union[str, "RecurrenceFrequency"],
+        interval: int,
+        schedule: "RecurrenceSchedule",
+        end_time: str,
+        start_time: str,
+        time_zone: str,
+        **kwargs
+    ):
+        """
+        :keyword frequency: Required. Possible values include: "Month", "Week", "Day", "Hour",
+         "Minute".
+        :paramtype frequency: str or ~index_service_apis.models.RecurrenceFrequency
+        :keyword interval: Required.
+        :paramtype interval: int
+        :keyword schedule: Required.
+        :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule
+        :keyword end_time: Required.
+        :paramtype end_time: str
+        :keyword start_time: Required.
+        :paramtype start_time: str
+        :keyword time_zone: Required.
+        :paramtype time_zone: str
+        """
+        super(Recurrence, self).__init__(**kwargs)
+        self.frequency = frequency
+        self.interval = interval
+        self.schedule = schedule
+        self.end_time = end_time
+        self.start_time = start_time
+        self.time_zone = time_zone
+
+
+class RecurrenceSchedule(msrest.serialization.Model):
+    """RecurrenceSchedule.
+
+    :ivar hours:
+    :vartype hours: list[int]
+    :ivar minutes:
+    :vartype minutes: list[int]
+    :ivar week_days:
+    :vartype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem]
+    :ivar month_days:
+    :vartype month_days: list[int]
+    """
+
+    _attribute_map = {
+        "hours": {"key": "hours", "type": "[int]"},
+        "minutes": {"key": "minutes", "type": "[int]"},
+        "week_days": {"key": "weekDays", "type": "[str]"},
+        "month_days": {"key": "monthDays", "type": "[int]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        hours: Optional[List[int]] = None,
+        minutes: Optional[List[int]] = None,
+        week_days: Optional[List[Union[str, "RecurrenceScheduleWeekDaysItem"]]] = None,
+        month_days: Optional[List[int]] = None,
+        **kwargs
+    ):
+        """
+        :keyword hours:
+        :paramtype hours: list[int]
+        :keyword minutes:
+        :paramtype minutes: list[int]
+        :keyword week_days:
+        :paramtype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem]
+        :keyword month_days:
+        :paramtype month_days: list[int]
+        """
+        super(RecurrenceSchedule, self).__init__(**kwargs)
+        self.hours = hours
+        self.minutes = minutes
+        self.week_days = week_days
+        self.month_days = month_days
+
+
+class RecurrenceTrigger(msrest.serialization.Model):
+    """RecurrenceTrigger.
+
+    :ivar frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute".
+    :vartype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency
+    :ivar interval:
+    :vartype interval: int
+    :ivar schedule:
+    :vartype schedule: ~index_service_apis.models.RecurrenceSchedule
+    """
+
+    _attribute_map = {
+        "frequency": {"key": "frequency", "type": "str"},
+        "interval": {"key": "interval", "type": "int"},
+        "schedule": {"key": "schedule", "type": "RecurrenceSchedule"},
+    }
+
+    def __init__(
+        self,
+        *,
+        frequency: Optional[Union[str, "RecurrenceTriggerFrequency"]] = None,
+        interval: Optional[int] = None,
+        schedule: Optional["RecurrenceSchedule"] = None,
+        **kwargs
+    ):
+        """
+        :keyword frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute".
+        :paramtype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency
+        :keyword interval:
+        :paramtype interval: int
+        :keyword schedule:
+        :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule
+        """
+        super(RecurrenceTrigger, self).__init__(**kwargs)
+        self.frequency = frequency
+        self.interval = interval
+        self.schedule = schedule
+
+
+class Relationship(msrest.serialization.Model):
+    """Relationship.
+
+    Variables are only populated by the server, and will be ignored when sending a request.
+
+    :ivar additional_properties: Unmatched properties from the message are deserialized to this
+     collection.
+    :vartype additional_properties: dict[str, any]
+    :ivar relation_type:
+    :vartype relation_type: str
+    :ivar target_entity_id:
+    :vartype target_entity_id: str
+    :ivar asset_id:
+    :vartype asset_id: str
+    :ivar entity_type:
+    :vartype entity_type: str
+    :ivar direction:
+    :vartype direction: str
+    :ivar entity_container_id:
+    :vartype entity_container_id: str
+    """
+
+    _validation = {
+        "entity_type": {"readonly": True},
+        "entity_container_id": {"readonly": True},
+    }
+
+    _attribute_map = {
+        "additional_properties": {"key": "", "type": "{object}"},
+        "relation_type": {"key": "relationType", "type": "str"},
+        "target_entity_id": {"key": "targetEntityId", "type": "str"},
+        "asset_id": {"key": "assetId", "type": "str"},
+        "entity_type": {"key": "entityType", "type": "str"},
+        "direction": {"key": "direction", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        additional_properties: Optional[Dict[str, Any]] = None,
+        relation_type: Optional[str] = None,
+        target_entity_id: Optional[str] = None,
+        asset_id: Optional[str] = None,
+        direction: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword additional_properties: Unmatched properties from the message are deserialized to this
+         collection.
+        :paramtype additional_properties: dict[str, any]
+        :keyword relation_type:
+        :paramtype relation_type: str
+        :keyword target_entity_id:
+        :paramtype target_entity_id: str
+        :keyword asset_id:
+        :paramtype asset_id: str
+        :keyword direction:
+        :paramtype direction: str
+        """
+        super(Relationship, self).__init__(**kwargs)
+        self.additional_properties = additional_properties
+        self.relation_type = relation_type
+        self.target_entity_id = target_entity_id
+        self.asset_id = asset_id
+        self.entity_type = None
+        self.direction = direction
+        self.entity_container_id = None
+
+
+class ResourceDiscoveryContainerMetadata(msrest.serialization.Model):
+    """ResourceDiscoveryContainerMetadata.
+
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    :ivar tenant_id:
+    :vartype tenant_id: str
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar resource_arm_id:
+    :vartype resource_arm_id: str
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group:
+    :vartype resource_group: str
+    :ivar resource_name:
+    :vartype resource_name: str
+    :ivar asset_container_type:
+    :vartype asset_container_type: str
+    :ivar immutable_resource_id:
+    :vartype immutable_resource_id: str
+    :ivar asset_resource_type:
+    :vartype asset_resource_type: str
+    :ivar is_customer_managed_resource:
+    :vartype is_customer_managed_resource: bool
+    :ivar is_private_link_behind_vnet:
+    :vartype is_private_link_behind_vnet: bool
+    :ivar is_public_container:
+    :vartype is_public_container: bool
+    :ivar is_public_resource:
+    :vartype is_public_resource: bool
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    """
+
+    _attribute_map = {
+        "tags": {"key": "tags", "type": "{str}"},
+        "tenant_id": {"key": "tenantId", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "resource_arm_id": {"key": "resourceArmId", "type": "str"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group": {"key": "resourceGroup", "type": "str"},
+        "resource_name": {"key": "resourceName", "type": "str"},
+        "asset_container_type": {"key": "assetContainerType", "type": "str"},
+        "immutable_resource_id": {"key": "immutableResourceId", "type": "str"},
+        "asset_resource_type": {"key": "assetResourceType", "type": "str"},
+        "is_customer_managed_resource": {"key": "isCustomerManagedResource", "type": "bool"},
+        "is_private_link_behind_vnet": {"key": "isPrivateLinkBehindVnet", "type": "bool"},
+        "is_public_container": {"key": "isPublicContainer", "type": "bool"},
+        "is_public_resource": {"key": "isPublicResource", "type": "bool"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        tags: Optional[Dict[str, str]] = None,
+        tenant_id: Optional[str] = None,
+        resource_id: Optional[str] = None,
+        resource_arm_id: Optional[str] = None,
+        subscription_id: Optional[str] = None,
+        resource_group: Optional[str] = None,
+        resource_name: Optional[str] = None,
+        asset_container_type: Optional[str] = None,
+        immutable_resource_id: Optional[str] = None,
+        asset_resource_type: Optional[str] = None,
+        is_customer_managed_resource: Optional[bool] = None,
+        is_private_link_behind_vnet: Optional[bool] = None,
+        is_public_container: Optional[bool] = None,
+        is_public_resource: Optional[bool] = None,
+        regions: Optional[List["ResourceRegion"]] = None,
+        **kwargs
+    ):
+        """
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        :keyword tenant_id:
+        :paramtype tenant_id: str
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword resource_arm_id:
+        :paramtype resource_arm_id: str
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group:
+        :paramtype resource_group: str
+        :keyword resource_name:
+        :paramtype resource_name: str
+        :keyword asset_container_type:
+        :paramtype asset_container_type: str
+        :keyword immutable_resource_id:
+        :paramtype immutable_resource_id: str
+        :keyword asset_resource_type:
+        :paramtype asset_resource_type: str
+        :keyword is_customer_managed_resource:
+        :paramtype is_customer_managed_resource: bool
+        :keyword is_private_link_behind_vnet:
+        :paramtype is_private_link_behind_vnet: bool
+        :keyword is_public_container:
+        :paramtype is_public_container: bool
+        :keyword is_public_resource:
+        :paramtype is_public_resource: bool
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        """
+        super(ResourceDiscoveryContainerMetadata, self).__init__(**kwargs)
+        self.tags = tags
+        self.tenant_id = tenant_id
+        self.resource_id = resource_id
+        self.resource_arm_id = resource_arm_id
+        self.subscription_id = subscription_id
+        self.resource_group = resource_group
+        self.resource_name = resource_name
+        self.asset_container_type = asset_container_type
+        self.immutable_resource_id = immutable_resource_id
+        self.asset_resource_type = asset_resource_type
+        self.is_customer_managed_resource = is_customer_managed_resource
+        self.is_private_link_behind_vnet = is_private_link_behind_vnet
+        self.is_public_container = is_public_container
+        self.is_public_resource = is_public_resource
+        self.regions = regions
+
+
+class ResourceDiscoveryContainerMetadataPaginatedResult(msrest.serialization.Model):
+    """ResourceDiscoveryContainerMetadataPaginatedResult.
+
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata]
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar next_link:
+    :vartype next_link: str
+    """
+
+    _attribute_map = {
+        "value": {"key": "value", "type": "[ResourceDiscoveryContainerMetadata]"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "next_link": {"key": "nextLink", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        value: Optional[List["ResourceDiscoveryContainerMetadata"]] = None,
+        continuation_token: Optional[str] = None,
+        next_link: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata]
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword next_link:
+        :paramtype next_link: str
+        """
+        super(ResourceDiscoveryContainerMetadataPaginatedResult, self).__init__(**kwargs)
+        self.value = value
+        self.continuation_token = continuation_token
+        self.next_link = next_link
+
+
+class ResourceDiscoveryRequest(msrest.serialization.Model):
+    """ResourceDiscoveryRequest.
+
+    :ivar search_request:
+    :vartype search_request: ~index_service_apis.models.StringContainsRequest
+    :ivar order_by:
+    :vartype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder
+    :ivar filters:
+    :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+    :ivar page_size:
+    :vartype page_size: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    """
+
+    _attribute_map = {
+        "search_request": {"key": "searchRequest", "type": "StringContainsRequest"},
+        "order_by": {"key": "orderBy", "type": "IndexEntitiesRequestOrder"},
+        "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"},
+        "page_size": {"key": "pageSize", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        search_request: Optional["StringContainsRequest"] = None,
+        order_by: Optional["IndexEntitiesRequestOrder"] = None,
+        filters: Optional[List["IndexEntitiesRequestFilter"]] = None,
+        page_size: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword search_request:
+        :paramtype search_request: ~index_service_apis.models.StringContainsRequest
+        :keyword order_by:
+        :paramtype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder
+        :keyword filters:
+        :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter]
+        :keyword page_size:
+        :paramtype page_size: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        """
+        super(ResourceDiscoveryRequest, self).__init__(**kwargs)
+        self.search_request = search_request
+        self.order_by = order_by
+        self.filters = filters
+        self.page_size = page_size
+        self.continuation_token = continuation_token
+
+
+class ResourceInformation(msrest.serialization.Model):
+    """ResourceInformation.
+
+    :ivar region:
+    :vartype region: str
+    :ivar entity_container_type: Possible values include: "Workspace", "Feed", "Registry".
+    :vartype entity_container_type: str or ~index_service_apis.models.AssetContainerTypeFeedRename
+    :ivar resource_id:
+    :vartype resource_id: str
+    """
+
+    _attribute_map = {
+        "region": {"key": "region", "type": "str"},
+        "entity_container_type": {"key": "entityContainerType", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        region: Optional[str] = None,
+        entity_container_type: Optional[Union[str, "AssetContainerTypeFeedRename"]] = None,
+        resource_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword region:
+        :paramtype region: str
+        :keyword entity_container_type: Possible values include: "Workspace", "Feed", "Registry".
+        :paramtype entity_container_type: str or
+         ~index_service_apis.models.AssetContainerTypeFeedRename
+        :keyword resource_id:
+        :paramtype resource_id: str
+        """
+        super(ResourceInformation, self).__init__(**kwargs)
+        self.region = region
+        self.entity_container_type = entity_container_type
+        self.resource_id = resource_id
+
+
+class ResourceRegion(msrest.serialization.Model):
+    """ResourceRegion.
+
+    :ivar region_name:
+    :vartype region_name: str
+    :ivar is_primary_region:
+    :vartype is_primary_region: bool
+    """
+
+    _attribute_map = {
+        "region_name": {"key": "regionName", "type": "str"},
+        "is_primary_region": {"key": "isPrimaryRegion", "type": "bool"},
+    }
+
+    def __init__(self, *, region_name: Optional[str] = None, is_primary_region: Optional[bool] = None, **kwargs):
+        """
+        :keyword region_name:
+        :paramtype region_name: str
+        :keyword is_primary_region:
+        :paramtype is_primary_region: bool
+        """
+        super(ResourceRegion, self).__init__(**kwargs)
+        self.region_name = region_name
+        self.is_primary_region = is_primary_region
+
+
+class RootError(msrest.serialization.Model):
+    """RootError.
+
+    :ivar code:
+    :vartype code: str
+    :ivar severity:
+    :vartype severity: int
+    :ivar message:
+    :vartype message: str
+    :ivar message_format:
+    :vartype message_format: str
+    :ivar message_parameters: Dictionary of :code:`<string>`.
+    :vartype message_parameters: dict[str, str]
+    :ivar reference_code:
+    :vartype reference_code: str
+    :ivar details_uri:
+    :vartype details_uri: str
+    :ivar target:
+    :vartype target: str
+    :ivar details:
+    :vartype details: list[~index_service_apis.models.RootError]
+    :ivar inner_error:
+    :vartype inner_error: ~index_service_apis.models.InnerErrorResponse
+    :ivar debug_info:
+    :vartype debug_info: ~index_service_apis.models.DebugInfoResponse
+    :ivar additional_info:
+    :vartype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo]
+    """
+
+    _attribute_map = {
+        "code": {"key": "code", "type": "str"},
+        "severity": {"key": "severity", "type": "int"},
+        "message": {"key": "message", "type": "str"},
+        "message_format": {"key": "messageFormat", "type": "str"},
+        "message_parameters": {"key": "messageParameters", "type": "{str}"},
+        "reference_code": {"key": "referenceCode", "type": "str"},
+        "details_uri": {"key": "detailsUri", "type": "str"},
+        "target": {"key": "target", "type": "str"},
+        "details": {"key": "details", "type": "[RootError]"},
+        "inner_error": {"key": "innerError", "type": "InnerErrorResponse"},
+        "debug_info": {"key": "debugInfo", "type": "DebugInfoResponse"},
+        "additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        code: Optional[str] = None,
+        severity: Optional[int] = None,
+        message: Optional[str] = None,
+        message_format: Optional[str] = None,
+        message_parameters: Optional[Dict[str, str]] = None,
+        reference_code: Optional[str] = None,
+        details_uri: Optional[str] = None,
+        target: Optional[str] = None,
+        details: Optional[List["RootError"]] = None,
+        inner_error: Optional["InnerErrorResponse"] = None,
+        debug_info: Optional["DebugInfoResponse"] = None,
+        additional_info: Optional[List["ErrorAdditionalInfo"]] = None,
+        **kwargs
+    ):
+        """
+        :keyword code:
+        :paramtype code: str
+        :keyword severity:
+        :paramtype severity: int
+        :keyword message:
+        :paramtype message: str
+        :keyword message_format:
+        :paramtype message_format: str
+        :keyword message_parameters: Dictionary of :code:`<string>`.
+        :paramtype message_parameters: dict[str, str]
+        :keyword reference_code:
+        :paramtype reference_code: str
+        :keyword details_uri:
+        :paramtype details_uri: str
+        :keyword target:
+        :paramtype target: str
+        :keyword details:
+        :paramtype details: list[~index_service_apis.models.RootError]
+        :keyword inner_error:
+        :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse
+        :keyword debug_info:
+        :paramtype debug_info: ~index_service_apis.models.DebugInfoResponse
+        :keyword additional_info:
+        :paramtype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo]
+        """
+        super(RootError, self).__init__(**kwargs)
+        self.code = code
+        self.severity = severity
+        self.message = message
+        self.message_format = message_format
+        self.message_parameters = message_parameters
+        self.reference_code = reference_code
+        self.details_uri = details_uri
+        self.target = target
+        self.details = details
+        self.inner_error = inner_error
+        self.debug_info = debug_info
+        self.additional_info = additional_info
+
+
+class RunAnnotations(msrest.serialization.Model):
+    """RunAnnotations.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar display_name: Required.
+    :vartype display_name: str
+    :ivar status: Required.
+    :vartype status: str
+    :ivar primary_metric_name: Required.
+    :vartype primary_metric_name: str
+    :ivar estimated_cost: Required.
+    :vartype estimated_cost: float
+    :ivar primary_metric_summary: Required.
+    :vartype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue
+    :ivar metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>.
+    :vartype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject]
+    :ivar parameters: Required. Dictionary of :code:`<AnyObject>`.
+    :vartype parameters: dict[str, any]
+    :ivar settings: Required. Dictionary of :code:`<string>`.
+    :vartype settings: dict[str, str]
+    :ivar modified_time: Required.
+    :vartype modified_time: ~datetime.datetime
+    :ivar retain_for_lifetime_of_workspace: Required.
+    :vartype retain_for_lifetime_of_workspace: bool
+    :ivar error: Required.
+    :vartype error: ~index_service_apis.models.IndexedErrorResponse
+    :ivar resource_metric_summary: Required.
+    :vartype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary
+    :ivar job_cost: Required.
+    :vartype job_cost: ~index_service_apis.models.JobCost
+    :ivar compute_duration: Required.
+    :vartype compute_duration: str
+    :ivar compute_duration_milliseconds: Required.
+    :vartype compute_duration_milliseconds: float
+    :ivar effective_start_time_utc: Required.
+    :vartype effective_start_time_utc: ~datetime.datetime
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar archived: Required.
+    :vartype archived: bool
+    :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    """
+
+    _validation = {
+        "display_name": {"required": True},
+        "status": {"required": True},
+        "primary_metric_name": {"required": True},
+        "estimated_cost": {"required": True},
+        "primary_metric_summary": {"required": True},
+        "metrics": {"required": True},
+        "parameters": {"required": True},
+        "settings": {"required": True},
+        "modified_time": {"required": True},
+        "retain_for_lifetime_of_workspace": {"required": True},
+        "error": {"required": True},
+        "resource_metric_summary": {"required": True},
+        "job_cost": {"required": True},
+        "compute_duration": {"required": True},
+        "compute_duration_milliseconds": {"required": True},
+        "effective_start_time_utc": {"required": True},
+        "name": {"required": True},
+        "description": {"required": True},
+        "archived": {"required": True},
+        "tags": {"required": True},
+    }
+
+    _attribute_map = {
+        "display_name": {"key": "displayName", "type": "str"},
+        "status": {"key": "status", "type": "str"},
+        "primary_metric_name": {"key": "primaryMetricName", "type": "str"},
+        "estimated_cost": {"key": "estimatedCost", "type": "float"},
+        "primary_metric_summary": {"key": "primaryMetricSummary", "type": "RunIndexMetricSummaryJValue"},
+        "metrics": {"key": "metrics", "type": "{RunIndexMetricSummaryObject}"},
+        "parameters": {"key": "parameters", "type": "{object}"},
+        "settings": {"key": "settings", "type": "{str}"},
+        "modified_time": {"key": "modifiedTime", "type": "iso-8601"},
+        "retain_for_lifetime_of_workspace": {"key": "retainForLifetimeOfWorkspace", "type": "bool"},
+        "error": {"key": "error", "type": "IndexedErrorResponse"},
+        "resource_metric_summary": {"key": "resourceMetricSummary", "type": "RunIndexResourceMetricSummary"},
+        "job_cost": {"key": "jobCost", "type": "JobCost"},
+        "compute_duration": {"key": "computeDuration", "type": "str"},
+        "compute_duration_milliseconds": {"key": "computeDurationMilliseconds", "type": "float"},
+        "effective_start_time_utc": {"key": "effectiveStartTimeUtc", "type": "iso-8601"},
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "archived": {"key": "archived", "type": "bool"},
+        "tags": {"key": "tags", "type": "{str}"},
+    }
+
+    def __init__(
+        self,
+        *,
+        display_name: str,
+        status: str,
+        primary_metric_name: str,
+        estimated_cost: float,
+        primary_metric_summary: "RunIndexMetricSummaryJValue",
+        metrics: Dict[str, "RunIndexMetricSummaryObject"],
+        parameters: Dict[str, Any],
+        settings: Dict[str, str],
+        modified_time: datetime.datetime,
+        retain_for_lifetime_of_workspace: bool,
+        error: "IndexedErrorResponse",
+        resource_metric_summary: "RunIndexResourceMetricSummary",
+        job_cost: "JobCost",
+        compute_duration: str,
+        compute_duration_milliseconds: float,
+        effective_start_time_utc: datetime.datetime,
+        name: str,
+        description: str,
+        archived: bool,
+        tags: Dict[str, str],
+        **kwargs
+    ):
+        """
+        :keyword display_name: Required.
+        :paramtype display_name: str
+        :keyword status: Required.
+        :paramtype status: str
+        :keyword primary_metric_name: Required.
+        :paramtype primary_metric_name: str
+        :keyword estimated_cost: Required.
+        :paramtype estimated_cost: float
+        :keyword primary_metric_summary: Required.
+        :paramtype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue
+        :keyword metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>.
+        :paramtype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject]
+        :keyword parameters: Required. Dictionary of :code:`<AnyObject>`.
+        :paramtype parameters: dict[str, any]
+        :keyword settings: Required. Dictionary of :code:`<string>`.
+        :paramtype settings: dict[str, str]
+        :keyword modified_time: Required.
+        :paramtype modified_time: ~datetime.datetime
+        :keyword retain_for_lifetime_of_workspace: Required.
+        :paramtype retain_for_lifetime_of_workspace: bool
+        :keyword error: Required.
+        :paramtype error: ~index_service_apis.models.IndexedErrorResponse
+        :keyword resource_metric_summary: Required.
+        :paramtype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary
+        :keyword job_cost: Required.
+        :paramtype job_cost: ~index_service_apis.models.JobCost
+        :keyword compute_duration: Required.
+        :paramtype compute_duration: str
+        :keyword compute_duration_milliseconds: Required.
+        :paramtype compute_duration_milliseconds: float
+        :keyword effective_start_time_utc: Required.
+        :paramtype effective_start_time_utc: ~datetime.datetime
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword archived: Required.
+        :paramtype archived: bool
+        :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        """
+        super(RunAnnotations, self).__init__(**kwargs)
+        self.display_name = display_name
+        self.status = status
+        self.primary_metric_name = primary_metric_name
+        self.estimated_cost = estimated_cost
+        self.primary_metric_summary = primary_metric_summary
+        self.metrics = metrics
+        self.parameters = parameters
+        self.settings = settings
+        self.modified_time = modified_time
+        self.retain_for_lifetime_of_workspace = retain_for_lifetime_of_workspace
+        self.error = error
+        self.resource_metric_summary = resource_metric_summary
+        self.job_cost = job_cost
+        self.compute_duration = compute_duration
+        self.compute_duration_milliseconds = compute_duration_milliseconds
+        self.effective_start_time_utc = effective_start_time_utc
+        self.name = name
+        self.description = description
+        self.archived = archived
+        self.tags = tags
+
+
+class RunIndexMetricSummaryJValue(msrest.serialization.Model):
+    """RunIndexMetricSummaryJValue.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar count: Required.
+    :vartype count: int
+    :ivar last_value: Required. Any object.
+    :vartype last_value: any
+    :ivar minimum_value: Required. Any object.
+    :vartype minimum_value: any
+    :ivar maximum_value: Required. Any object.
+    :vartype maximum_value: any
+    :ivar metric_type: Required.
+    :vartype metric_type: str
+    """
+
+    _validation = {
+        "count": {"required": True},
+        "last_value": {"required": True},
+        "minimum_value": {"required": True},
+        "maximum_value": {"required": True},
+        "metric_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "count": {"key": "count", "type": "int"},
+        "last_value": {"key": "lastValue", "type": "object"},
+        "minimum_value": {"key": "minimumValue", "type": "object"},
+        "maximum_value": {"key": "maximumValue", "type": "object"},
+        "metric_type": {"key": "metricType", "type": "str"},
+    }
+
+    def __init__(
+        self, *, count: int, last_value: Any, minimum_value: Any, maximum_value: Any, metric_type: str, **kwargs
+    ):
+        """
+        :keyword count: Required.
+        :paramtype count: int
+        :keyword last_value: Required. Any object.
+        :paramtype last_value: any
+        :keyword minimum_value: Required. Any object.
+        :paramtype minimum_value: any
+        :keyword maximum_value: Required. Any object.
+        :paramtype maximum_value: any
+        :keyword metric_type: Required.
+        :paramtype metric_type: str
+        """
+        super(RunIndexMetricSummaryJValue, self).__init__(**kwargs)
+        self.count = count
+        self.last_value = last_value
+        self.minimum_value = minimum_value
+        self.maximum_value = maximum_value
+        self.metric_type = metric_type
+
+
+class RunIndexMetricSummaryObject(msrest.serialization.Model):
+    """RunIndexMetricSummaryObject.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar count: Required.
+    :vartype count: int
+    :ivar last_value: Required. Anything.
+    :vartype last_value: any
+    :ivar minimum_value: Required. Anything.
+    :vartype minimum_value: any
+    :ivar maximum_value: Required. Anything.
+    :vartype maximum_value: any
+    :ivar metric_type: Required.
+    :vartype metric_type: str
+    """
+
+    _validation = {
+        "count": {"required": True},
+        "last_value": {"required": True},
+        "minimum_value": {"required": True},
+        "maximum_value": {"required": True},
+        "metric_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "count": {"key": "count", "type": "int"},
+        "last_value": {"key": "lastValue", "type": "object"},
+        "minimum_value": {"key": "minimumValue", "type": "object"},
+        "maximum_value": {"key": "maximumValue", "type": "object"},
+        "metric_type": {"key": "metricType", "type": "str"},
+    }
+
+    def __init__(
+        self, *, count: int, last_value: Any, minimum_value: Any, maximum_value: Any, metric_type: str, **kwargs
+    ):
+        """
+        :keyword count: Required.
+        :paramtype count: int
+        :keyword last_value: Required. Anything.
+        :paramtype last_value: any
+        :keyword minimum_value: Required. Anything.
+        :paramtype minimum_value: any
+        :keyword maximum_value: Required. Anything.
+        :paramtype maximum_value: any
+        :keyword metric_type: Required.
+        :paramtype metric_type: str
+        """
+        super(RunIndexMetricSummaryObject, self).__init__(**kwargs)
+        self.count = count
+        self.last_value = last_value
+        self.minimum_value = minimum_value
+        self.maximum_value = maximum_value
+        self.metric_type = metric_type
+
+
+class RunIndexResourceMetricSummary(msrest.serialization.Model):
+    """RunIndexResourceMetricSummary.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar gpu_utilization_percent_last_hour: Required.
+    :vartype gpu_utilization_percent_last_hour: float
+    :ivar gpu_memory_utilization_percent_last_hour: Required.
+    :vartype gpu_memory_utilization_percent_last_hour: float
+    :ivar gpu_energy_joules: Required.
+    :vartype gpu_energy_joules: float
+    :ivar resource_metric_names: Required.
+    :vartype resource_metric_names: list[str]
+    """
+
+    _validation = {
+        "gpu_utilization_percent_last_hour": {"required": True},
+        "gpu_memory_utilization_percent_last_hour": {"required": True},
+        "gpu_energy_joules": {"required": True},
+        "resource_metric_names": {"required": True},
+    }
+
+    _attribute_map = {
+        "gpu_utilization_percent_last_hour": {"key": "gpuUtilizationPercentLastHour", "type": "float"},
+        "gpu_memory_utilization_percent_last_hour": {"key": "gpuMemoryUtilizationPercentLastHour", "type": "float"},
+        "gpu_energy_joules": {"key": "gpuEnergyJoules", "type": "float"},
+        "resource_metric_names": {"key": "resourceMetricNames", "type": "[str]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        gpu_utilization_percent_last_hour: float,
+        gpu_memory_utilization_percent_last_hour: float,
+        gpu_energy_joules: float,
+        resource_metric_names: List[str],
+        **kwargs
+    ):
+        """
+        :keyword gpu_utilization_percent_last_hour: Required.
+        :paramtype gpu_utilization_percent_last_hour: float
+        :keyword gpu_memory_utilization_percent_last_hour: Required.
+        :paramtype gpu_memory_utilization_percent_last_hour: float
+        :keyword gpu_energy_joules: Required.
+        :paramtype gpu_energy_joules: float
+        :keyword resource_metric_names: Required.
+        :paramtype resource_metric_names: list[str]
+        """
+        super(RunIndexResourceMetricSummary, self).__init__(**kwargs)
+        self.gpu_utilization_percent_last_hour = gpu_utilization_percent_last_hour
+        self.gpu_memory_utilization_percent_last_hour = gpu_memory_utilization_percent_last_hour
+        self.gpu_energy_joules = gpu_energy_joules
+        self.resource_metric_names = resource_metric_names
+
+
+class RunProperties(msrest.serialization.Model):
+    """RunProperties.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar data_container_id: Required.
+    :vartype data_container_id: str
+    :ivar target_name: Required.
+    :vartype target_name: str
+    :ivar run_name: Required.
+    :vartype run_name: str
+    :ivar experiment_name: Required.
+    :vartype experiment_name: str
+    :ivar run_id: Required.
+    :vartype run_id: str
+    :ivar parent_run_id: Required.
+    :vartype parent_run_id: str
+    :ivar root_run_id: Required.
+    :vartype root_run_id: str
+    :ivar run_type: Required.
+    :vartype run_type: str
+    :ivar run_type_v2: Required.
+    :vartype run_type_v2: ~index_service_apis.models.RunTypeV2Index
+    :ivar script_name: Required.
+    :vartype script_name: str
+    :ivar experiment_id: Required.
+    :vartype experiment_id: str
+    :ivar run_uuid: Required.
+    :vartype run_uuid: str
+    :ivar parent_run_uuid: Required.
+    :vartype parent_run_uuid: str
+    :ivar run_number: Required.
+    :vartype run_number: int
+    :ivar start_time: Required.
+    :vartype start_time: ~datetime.datetime
+    :ivar end_time: Required.
+    :vartype end_time: ~datetime.datetime
+    :ivar compute_request: Required.
+    :vartype compute_request: ~index_service_apis.models.ComputeRequest
+    :ivar compute: Required.
+    :vartype compute: ~index_service_apis.models.Compute
+    :ivar user_properties: Required. Dictionary of :code:`<string>`.
+    :vartype user_properties: dict[str, str]
+    :ivar action_uris: Required. Dictionary of :code:`<string>`.
+    :vartype action_uris: dict[str, str]
+    :ivar duration: Required.
+    :vartype duration: str
+    :ivar duration_milliseconds: Required.
+    :vartype duration_milliseconds: float
+    :ivar creation_context: Required.
+    :vartype creation_context: ~index_service_apis.models.CreationContext
+    """
+
+    _validation = {
+        "data_container_id": {"required": True},
+        "target_name": {"required": True},
+        "run_name": {"required": True},
+        "experiment_name": {"required": True},
+        "run_id": {"required": True},
+        "parent_run_id": {"required": True},
+        "root_run_id": {"required": True},
+        "run_type": {"required": True},
+        "run_type_v2": {"required": True},
+        "script_name": {"required": True},
+        "experiment_id": {"required": True},
+        "run_uuid": {"required": True},
+        "parent_run_uuid": {"required": True},
+        "run_number": {"required": True},
+        "start_time": {"required": True},
+        "end_time": {"required": True},
+        "compute_request": {"required": True},
+        "compute": {"required": True},
+        "user_properties": {"required": True},
+        "action_uris": {"required": True},
+        "duration": {"required": True},
+        "duration_milliseconds": {"required": True},
+        "creation_context": {"required": True},
+    }
+
+    _attribute_map = {
+        "data_container_id": {"key": "dataContainerId", "type": "str"},
+        "target_name": {"key": "targetName", "type": "str"},
+        "run_name": {"key": "runName", "type": "str"},
+        "experiment_name": {"key": "experimentName", "type": "str"},
+        "run_id": {"key": "runId", "type": "str"},
+        "parent_run_id": {"key": "parentRunId", "type": "str"},
+        "root_run_id": {"key": "rootRunId", "type": "str"},
+        "run_type": {"key": "runType", "type": "str"},
+        "run_type_v2": {"key": "runTypeV2", "type": "RunTypeV2Index"},
+        "script_name": {"key": "scriptName", "type": "str"},
+        "experiment_id": {"key": "experimentId", "type": "str"},
+        "run_uuid": {"key": "runUuid", "type": "str"},
+        "parent_run_uuid": {"key": "parentRunUuid", "type": "str"},
+        "run_number": {"key": "runNumber", "type": "int"},
+        "start_time": {"key": "startTime", "type": "iso-8601"},
+        "end_time": {"key": "endTime", "type": "iso-8601"},
+        "compute_request": {"key": "computeRequest", "type": "ComputeRequest"},
+        "compute": {"key": "compute", "type": "Compute"},
+        "user_properties": {"key": "userProperties", "type": "{str}"},
+        "action_uris": {"key": "actionUris", "type": "{str}"},
+        "duration": {"key": "duration", "type": "str"},
+        "duration_milliseconds": {"key": "durationMilliseconds", "type": "float"},
+        "creation_context": {"key": "creationContext", "type": "CreationContext"},
+    }
+
+    def __init__(
+        self,
+        *,
+        data_container_id: str,
+        target_name: str,
+        run_name: str,
+        experiment_name: str,
+        run_id: str,
+        parent_run_id: str,
+        root_run_id: str,
+        run_type: str,
+        run_type_v2: "RunTypeV2Index",
+        script_name: str,
+        experiment_id: str,
+        run_uuid: str,
+        parent_run_uuid: str,
+        run_number: int,
+        start_time: datetime.datetime,
+        end_time: datetime.datetime,
+        compute_request: "ComputeRequest",
+        compute: "Compute",
+        user_properties: Dict[str, str],
+        action_uris: Dict[str, str],
+        duration: str,
+        duration_milliseconds: float,
+        creation_context: "CreationContext",
+        **kwargs
+    ):
+        """
+        :keyword data_container_id: Required.
+        :paramtype data_container_id: str
+        :keyword target_name: Required.
+        :paramtype target_name: str
+        :keyword run_name: Required.
+        :paramtype run_name: str
+        :keyword experiment_name: Required.
+        :paramtype experiment_name: str
+        :keyword run_id: Required.
+        :paramtype run_id: str
+        :keyword parent_run_id: Required.
+        :paramtype parent_run_id: str
+        :keyword root_run_id: Required.
+        :paramtype root_run_id: str
+        :keyword run_type: Required.
+        :paramtype run_type: str
+        :keyword run_type_v2: Required.
+        :paramtype run_type_v2: ~index_service_apis.models.RunTypeV2Index
+        :keyword script_name: Required.
+        :paramtype script_name: str
+        :keyword experiment_id: Required.
+        :paramtype experiment_id: str
+        :keyword run_uuid: Required.
+        :paramtype run_uuid: str
+        :keyword parent_run_uuid: Required.
+        :paramtype parent_run_uuid: str
+        :keyword run_number: Required.
+        :paramtype run_number: int
+        :keyword start_time: Required.
+        :paramtype start_time: ~datetime.datetime
+        :keyword end_time: Required.
+        :paramtype end_time: ~datetime.datetime
+        :keyword compute_request: Required.
+        :paramtype compute_request: ~index_service_apis.models.ComputeRequest
+        :keyword compute: Required.
+        :paramtype compute: ~index_service_apis.models.Compute
+        :keyword user_properties: Required. Dictionary of :code:`<string>`.
+        :paramtype user_properties: dict[str, str]
+        :keyword action_uris: Required. Dictionary of :code:`<string>`.
+        :paramtype action_uris: dict[str, str]
+        :keyword duration: Required.
+        :paramtype duration: str
+        :keyword duration_milliseconds: Required.
+        :paramtype duration_milliseconds: float
+        :keyword creation_context: Required.
+        :paramtype creation_context: ~index_service_apis.models.CreationContext
+        """
+        super(RunProperties, self).__init__(**kwargs)
+        self.data_container_id = data_container_id
+        self.target_name = target_name
+        self.run_name = run_name
+        self.experiment_name = experiment_name
+        self.run_id = run_id
+        self.parent_run_id = parent_run_id
+        self.root_run_id = root_run_id
+        self.run_type = run_type
+        self.run_type_v2 = run_type_v2
+        self.script_name = script_name
+        self.experiment_id = experiment_id
+        self.run_uuid = run_uuid
+        self.parent_run_uuid = parent_run_uuid
+        self.run_number = run_number
+        self.start_time = start_time
+        self.end_time = end_time
+        self.compute_request = compute_request
+        self.compute = compute
+        self.user_properties = user_properties
+        self.action_uris = action_uris
+        self.duration = duration
+        self.duration_milliseconds = duration_milliseconds
+        self.creation_context = creation_context
+
+
+class RunsUnversionedEntitiesResponse(msrest.serialization.Model):
+    """RunsUnversionedEntitiesResponse.
+
+    :ivar total_count:
+    :vartype total_count: long
+    :ivar value:
+    :vartype value: list[~index_service_apis.models.RunsUnversionedEntity]
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar continuation_token:
+    :vartype continuation_token: str
+    :ivar entity_container_ids_to_entity_container_metadata: Dictionary of
+     :code:`<IndexEntityContainerMetadata>`.
+    :vartype entity_container_ids_to_entity_container_metadata: dict[str,
+     ~index_service_apis.models.IndexEntityContainerMetadata]
+    :ivar number_of_entity_containers_not_queried:
+    :vartype number_of_entity_containers_not_queried: int
+    :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+    :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+    :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`.
+    :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+    :ivar
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+    :vartype
+     is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+     bool
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+        "value": {"key": "value", "type": "[RunsUnversionedEntity]"},
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "continuation_token": {"key": "continuationToken", "type": "str"},
+        "entity_container_ids_to_entity_container_metadata": {
+            "key": "entityContainerIdsToEntityContainerMetadata",
+            "type": "{IndexEntityContainerMetadata}",
+        },
+        "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"},
+        "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"},
+        "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"},
+        "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": {
+            "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern",
+            "type": "bool",
+        },
+    }
+
+    def __init__(
+        self,
+        *,
+        total_count: Optional[int] = None,
+        value: Optional[List["RunsUnversionedEntity"]] = None,
+        next_skip: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None,
+        number_of_entity_containers_not_queried: Optional[int] = None,
+        fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None,
+        shard_errors: Optional[Dict[str, "ErrorResponse"]] = None,
+        is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[
+            bool
+        ] = None,
+        **kwargs
+    ):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        :keyword value:
+        :paramtype value: list[~index_service_apis.models.RunsUnversionedEntity]
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword continuation_token:
+        :paramtype continuation_token: str
+        :keyword entity_container_ids_to_entity_container_metadata: Dictionary of
+         :code:`<IndexEntityContainerMetadata>`.
+        :paramtype entity_container_ids_to_entity_container_metadata: dict[str,
+         ~index_service_apis.models.IndexEntityContainerMetadata]
+        :keyword number_of_entity_containers_not_queried:
+        :paramtype number_of_entity_containers_not_queried: int
+        :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`.
+        :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData]
+        :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`.
+        :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse]
+        :keyword
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+        :paramtype
+         is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern:
+         bool
+        """
+        super(RunsUnversionedEntitiesResponse, self).__init__(**kwargs)
+        self.total_count = total_count
+        self.value = value
+        self.next_skip = next_skip
+        self.continuation_token = continuation_token
+        self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata
+        self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried
+        self.fanout_data = fanout_data
+        self.shard_errors = shard_errors
+        self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = (
+            is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern
+        )
+
+
+class RunsUnversionedEntity(msrest.serialization.Model):
+    """RunsUnversionedEntity.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar schema_id: Required.
+    :vartype schema_id: str
+    :ivar entity_id: Required.
+    :vartype entity_id: str
+    :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+     "Unversioned".
+    :vartype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind
+    :ivar annotations: Required.
+    :vartype annotations: ~index_service_apis.models.RunAnnotations
+    :ivar properties: Required.
+    :vartype properties: ~index_service_apis.models.RunProperties
+    :ivar internal: Required. Dictionary of :code:`<any>`.
+    :vartype internal: dict[str, any]
+    :ivar update_sequence: Required.
+    :vartype update_sequence: int
+    :ivar type: Required.
+    :vartype type: str
+    :ivar version: Required.
+    :vartype version: str
+    :ivar entity_container_id: Required.
+    :vartype entity_container_id: str
+    :ivar entity_object_id: Required.
+    :vartype entity_object_id: str
+    :ivar resource_type: Required.
+    :vartype resource_type: str
+    :ivar relationships: Required.
+    :vartype relationships: list[~index_service_apis.models.Relationship]
+    :ivar asset_id:
+    :vartype asset_id: str
+    """
+
+    _validation = {
+        "schema_id": {"required": True},
+        "entity_id": {"required": True},
+        "kind": {"required": True},
+        "annotations": {"required": True},
+        "properties": {"required": True},
+        "internal": {"required": True},
+        "update_sequence": {"required": True},
+        "type": {"required": True},
+        "version": {"required": True},
+        "entity_container_id": {"required": True},
+        "entity_object_id": {"required": True},
+        "resource_type": {"required": True},
+        "relationships": {"required": True},
+    }
+
+    _attribute_map = {
+        "schema_id": {"key": "schemaId", "type": "str"},
+        "entity_id": {"key": "entityId", "type": "str"},
+        "kind": {"key": "kind", "type": "str"},
+        "annotations": {"key": "annotations", "type": "RunAnnotations"},
+        "properties": {"key": "properties", "type": "RunProperties"},
+        "internal": {"key": "internal", "type": "{object}"},
+        "update_sequence": {"key": "updateSequence", "type": "int"},
+        "type": {"key": "type", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+        "entity_container_id": {"key": "entityContainerId", "type": "str"},
+        "entity_object_id": {"key": "entityObjectId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "relationships": {"key": "relationships", "type": "[Relationship]"},
+        "asset_id": {"key": "assetId", "type": "str"},
+    }
+
+    def __init__(
+        self,
+        *,
+        schema_id: str,
+        entity_id: str,
+        kind: Union[str, "RunsUnversionedEntityKind"],
+        annotations: "RunAnnotations",
+        properties: "RunProperties",
+        internal: Dict[str, Any],
+        update_sequence: int,
+        type: str,
+        version: str,
+        entity_container_id: str,
+        entity_object_id: str,
+        resource_type: str,
+        relationships: List["Relationship"],
+        asset_id: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        :keyword schema_id: Required.
+        :paramtype schema_id: str
+        :keyword entity_id: Required.
+        :paramtype entity_id: str
+        :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned",
+         "Unversioned".
+        :paramtype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind
+        :keyword annotations: Required.
+        :paramtype annotations: ~index_service_apis.models.RunAnnotations
+        :keyword properties: Required.
+        :paramtype properties: ~index_service_apis.models.RunProperties
+        :keyword internal: Required. Dictionary of :code:`<any>`.
+        :paramtype internal: dict[str, any]
+        :keyword update_sequence: Required.
+        :paramtype update_sequence: int
+        :keyword type: Required.
+        :paramtype type: str
+        :keyword version: Required.
+        :paramtype version: str
+        :keyword entity_container_id: Required.
+        :paramtype entity_container_id: str
+        :keyword entity_object_id: Required.
+        :paramtype entity_object_id: str
+        :keyword resource_type: Required.
+        :paramtype resource_type: str
+        :keyword relationships: Required.
+        :paramtype relationships: list[~index_service_apis.models.Relationship]
+        :keyword asset_id:
+        :paramtype asset_id: str
+        """
+        super(RunsUnversionedEntity, self).__init__(**kwargs)
+        self.schema_id = schema_id
+        self.entity_id = entity_id
+        self.kind = kind
+        self.annotations = annotations
+        self.properties = properties
+        self.internal = internal
+        self.update_sequence = update_sequence
+        self.type = type
+        self.version = version
+        self.entity_container_id = entity_container_id
+        self.entity_object_id = entity_object_id
+        self.resource_type = resource_type
+        self.relationships = relationships
+        self.asset_id = asset_id
+
+
+class RunTypeV2Index(msrest.serialization.Model):
+    """RunTypeV2Index.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar orchestrator: Required.
+    :vartype orchestrator: str
+    :ivar traits: Required. Dictionary of :code:`<string>`.
+    :vartype traits: dict[str, str]
+    :ivar attribution: Required.
+    :vartype attribution: str
+    :ivar compute_type: Required.
+    :vartype compute_type: str
+    """
+
+    _validation = {
+        "orchestrator": {"required": True},
+        "traits": {"required": True},
+        "attribution": {"required": True},
+        "compute_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "orchestrator": {"key": "orchestrator", "type": "str"},
+        "traits": {"key": "traits", "type": "{str}"},
+        "attribution": {"key": "attribution", "type": "str"},
+        "compute_type": {"key": "computeType", "type": "str"},
+    }
+
+    def __init__(self, *, orchestrator: str, traits: Dict[str, str], attribution: str, compute_type: str, **kwargs):
+        """
+        :keyword orchestrator: Required.
+        :paramtype orchestrator: str
+        :keyword traits: Required. Dictionary of :code:`<string>`.
+        :paramtype traits: dict[str, str]
+        :keyword attribution: Required.
+        :paramtype attribution: str
+        :keyword compute_type: Required.
+        :paramtype compute_type: str
+        """
+        super(RunTypeV2Index, self).__init__(**kwargs)
+        self.orchestrator = orchestrator
+        self.traits = traits
+        self.attribution = attribution
+        self.compute_type = compute_type
+
+
+class SingleShardFanoutData(msrest.serialization.Model):
+    """SingleShardFanoutData.
+
+    :ivar next_skip:
+    :vartype next_skip: int
+    :ivar is_shard_done:
+    :vartype is_shard_done: bool
+    :ivar did_shard_fail:
+    :vartype did_shard_fail: bool
+    :ivar total_count:
+    :vartype total_count: long
+    """
+
+    _attribute_map = {
+        "next_skip": {"key": "nextSkip", "type": "int"},
+        "is_shard_done": {"key": "isShardDone", "type": "bool"},
+        "did_shard_fail": {"key": "didShardFail", "type": "bool"},
+        "total_count": {"key": "totalCount", "type": "long"},
+    }
+
+    def __init__(
+        self,
+        *,
+        next_skip: Optional[int] = None,
+        is_shard_done: Optional[bool] = None,
+        did_shard_fail: Optional[bool] = None,
+        total_count: Optional[int] = None,
+        **kwargs
+    ):
+        """
+        :keyword next_skip:
+        :paramtype next_skip: int
+        :keyword is_shard_done:
+        :paramtype is_shard_done: bool
+        :keyword did_shard_fail:
+        :paramtype did_shard_fail: bool
+        :keyword total_count:
+        :paramtype total_count: long
+        """
+        super(SingleShardFanoutData, self).__init__(**kwargs)
+        self.next_skip = next_skip
+        self.is_shard_done = is_shard_done
+        self.did_shard_fail = did_shard_fail
+        self.total_count = total_count
+
+
+class StringContainsRequest(msrest.serialization.Model):
+    """StringContainsRequest.
+
+    :ivar value_to_check:
+    :vartype value_to_check: str
+    :ivar columns_to_check:
+    :vartype columns_to_check: list[str]
+    """
+
+    _attribute_map = {
+        "value_to_check": {"key": "valueToCheck", "type": "str"},
+        "columns_to_check": {"key": "columnsToCheck", "type": "[str]"},
+    }
+
+    def __init__(self, *, value_to_check: Optional[str] = None, columns_to_check: Optional[List[str]] = None, **kwargs):
+        """
+        :keyword value_to_check:
+        :paramtype value_to_check: str
+        :keyword columns_to_check:
+        :paramtype columns_to_check: list[str]
+        """
+        super(StringContainsRequest, self).__init__(**kwargs)
+        self.value_to_check = value_to_check
+        self.columns_to_check = columns_to_check
+
+
+class StructuredInterfaceParameter(msrest.serialization.Model):
+    """StructuredInterfaceParameter.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar description: Required.
+    :vartype description: str
+    :ivar label: Required.
+    :vartype label: str
+    :ivar parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String",
+     "Undefined".
+    :vartype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType
+    :ivar is_optional: Required.
+    :vartype is_optional: bool
+    :ivar default_value: Required.
+    :vartype default_value: str
+    :ivar lower_bound: Required.
+    :vartype lower_bound: str
+    :ivar upper_bound: Required.
+    :vartype upper_bound: str
+    :ivar enum_values: Required.
+    :vartype enum_values: list[str]
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "description": {"required": True},
+        "label": {"required": True},
+        "parameter_type": {"required": True},
+        "is_optional": {"required": True},
+        "default_value": {"required": True},
+        "lower_bound": {"required": True},
+        "upper_bound": {"required": True},
+        "enum_values": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "description": {"key": "description", "type": "str"},
+        "label": {"key": "label", "type": "str"},
+        "parameter_type": {"key": "parameterType", "type": "str"},
+        "is_optional": {"key": "isOptional", "type": "bool"},
+        "default_value": {"key": "defaultValue", "type": "str"},
+        "lower_bound": {"key": "lowerBound", "type": "str"},
+        "upper_bound": {"key": "upperBound", "type": "str"},
+        "enum_values": {"key": "enumValues", "type": "[str]"},
+    }
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        description: str,
+        label: str,
+        parameter_type: Union[str, "StructuredInterfaceParameterType"],
+        is_optional: bool,
+        default_value: str,
+        lower_bound: str,
+        upper_bound: str,
+        enum_values: List[str],
+        **kwargs
+    ):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword description: Required.
+        :paramtype description: str
+        :keyword label: Required.
+        :paramtype label: str
+        :keyword parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String",
+         "Undefined".
+        :paramtype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType
+        :keyword is_optional: Required.
+        :paramtype is_optional: bool
+        :keyword default_value: Required.
+        :paramtype default_value: str
+        :keyword lower_bound: Required.
+        :paramtype lower_bound: str
+        :keyword upper_bound: Required.
+        :paramtype upper_bound: str
+        :keyword enum_values: Required.
+        :paramtype enum_values: list[str]
+        """
+        super(StructuredInterfaceParameter, self).__init__(**kwargs)
+        self.name = name
+        self.description = description
+        self.label = label
+        self.parameter_type = parameter_type
+        self.is_optional = is_optional
+        self.default_value = default_value
+        self.lower_bound = lower_bound
+        self.upper_bound = upper_bound
+        self.enum_values = enum_values
+
+
+class TimeDeltaDto(msrest.serialization.Model):
+    """TimeDeltaDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar days: Required.
+    :vartype days: int
+    :ivar hours: Required.
+    :vartype hours: int
+    :ivar minutes: Required.
+    :vartype minutes: int
+    """
+
+    _validation = {
+        "days": {"required": True},
+        "hours": {"required": True},
+        "minutes": {"required": True},
+    }
+
+    _attribute_map = {
+        "days": {"key": "days", "type": "int"},
+        "hours": {"key": "hours", "type": "int"},
+        "minutes": {"key": "minutes", "type": "int"},
+    }
+
+    def __init__(self, *, days: int, hours: int, minutes: int, **kwargs):
+        """
+        :keyword days: Required.
+        :paramtype days: int
+        :keyword hours: Required.
+        :paramtype hours: int
+        :keyword minutes: Required.
+        :paramtype minutes: int
+        """
+        super(TimeDeltaDto, self).__init__(**kwargs)
+        self.days = days
+        self.hours = hours
+        self.minutes = minutes
+
+
+class TimestampColumnDto(msrest.serialization.Model):
+    """TimestampColumnDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar format: Required.
+    :vartype format: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "format": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "format": {"key": "format", "type": "str"},
+    }
+
+    def __init__(self, *, name: str, format: str, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword format: Required.
+        :paramtype format: str
+        """
+        super(TimestampColumnDto, self).__init__(**kwargs)
+        self.name = name
+        self.format = format
+
+
+class UnqueriableResourcesScope(msrest.serialization.Model):
+    """UnqueriableResourcesScope.
+
+    :ivar resource_set:
+    :vartype resource_set: list[~index_service_apis.models.ResourceInformation]
+    """
+
+    _attribute_map = {
+        "resource_set": {"key": "resourceSet", "type": "[ResourceInformation]"},
+    }
+
+    def __init__(self, *, resource_set: Optional[List["ResourceInformation"]] = None, **kwargs):
+        """
+        :keyword resource_set:
+        :paramtype resource_set: list[~index_service_apis.models.ResourceInformation]
+        """
+        super(UnqueriableResourcesScope, self).__init__(**kwargs)
+        self.resource_set = resource_set
+
+
+class Usage(msrest.serialization.Model):
+    """Usage.
+
+    :ivar total_count:
+    :vartype total_count: long
+    """
+
+    _attribute_map = {
+        "total_count": {"key": "totalCount", "type": "long"},
+    }
+
+    def __init__(self, *, total_count: Optional[int] = None, **kwargs):
+        """
+        :keyword total_count:
+        :paramtype total_count: long
+        """
+        super(Usage, self).__init__(**kwargs)
+        self.total_count = total_count
+
+
+class UserDto(msrest.serialization.Model):
+    """UserDto.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar user_object_id: Required.
+    :vartype user_object_id: str
+    :ivar user_tenant_id: Required.
+    :vartype user_tenant_id: str
+    :ivar user_name: Required.
+    :vartype user_name: str
+    """
+
+    _validation = {
+        "user_object_id": {"required": True},
+        "user_tenant_id": {"required": True},
+        "user_name": {"required": True},
+    }
+
+    _attribute_map = {
+        "user_object_id": {"key": "userObjectId", "type": "str"},
+        "user_tenant_id": {"key": "userTenantId", "type": "str"},
+        "user_name": {"key": "userName", "type": "str"},
+    }
+
+    def __init__(self, *, user_object_id: str, user_tenant_id: str, user_name: str, **kwargs):
+        """
+        :keyword user_object_id: Required.
+        :paramtype user_object_id: str
+        :keyword user_tenant_id: Required.
+        :paramtype user_tenant_id: str
+        :keyword user_name: Required.
+        :paramtype user_name: str
+        """
+        super(UserDto, self).__init__(**kwargs)
+        self.user_object_id = user_object_id
+        self.user_tenant_id = user_tenant_id
+        self.user_name = user_name
+
+
+class UxPresenceResource(msrest.serialization.Model):
+    """UxPresenceResource.
+
+    :ivar name:
+    :vartype name: str
+    :ivar resource_id:
+    :vartype resource_id: str
+    :ivar resource_type:
+    :vartype resource_type: str
+    :ivar region:
+    :vartype region: str
+    :ivar regions:
+    :vartype regions: list[~index_service_apis.models.ResourceRegion]
+    :ivar subscription_id:
+    :vartype subscription_id: str
+    :ivar resource_group_name:
+    :vartype resource_group_name: str
+    :ivar tags: A set of tags. Dictionary of :code:`<string>`.
+    :vartype tags: dict[str, str]
+    :ivar is_customer_managed:
+    :vartype is_customer_managed: bool
+    :ivar is_private_link_resource:
+    :vartype is_private_link_resource: bool
+    :ivar is_private_link_resource_behind_vnet:
+    :vartype is_private_link_resource_behind_vnet: bool
+    """
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "resource_id": {"key": "resourceId", "type": "str"},
+        "resource_type": {"key": "resourceType", "type": "str"},
+        "region": {"key": "region", "type": "str"},
+        "regions": {"key": "regions", "type": "[ResourceRegion]"},
+        "subscription_id": {"key": "subscriptionId", "type": "str"},
+        "resource_group_name": {"key": "resourceGroupName", "type": "str"},
+        "tags": {"key": "tags", "type": "{str}"},
+        "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"},
+        "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"},
+        "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"},
+    }
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = None,
+        resource_id: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        region: Optional[str] = None,
+        regions: Optional[List["ResourceRegion"]] = None,
+        subscription_id: Optional[str] = None,
+        resource_group_name: Optional[str] = None,
+        tags: Optional[Dict[str, str]] = None,
+        is_customer_managed: Optional[bool] = None,
+        is_private_link_resource: Optional[bool] = None,
+        is_private_link_resource_behind_vnet: Optional[bool] = None,
+        **kwargs
+    ):
+        """
+        :keyword name:
+        :paramtype name: str
+        :keyword resource_id:
+        :paramtype resource_id: str
+        :keyword resource_type:
+        :paramtype resource_type: str
+        :keyword region:
+        :paramtype region: str
+        :keyword regions:
+        :paramtype regions: list[~index_service_apis.models.ResourceRegion]
+        :keyword subscription_id:
+        :paramtype subscription_id: str
+        :keyword resource_group_name:
+        :paramtype resource_group_name: str
+        :keyword tags: A set of tags. Dictionary of :code:`<string>`.
+        :paramtype tags: dict[str, str]
+        :keyword is_customer_managed:
+        :paramtype is_customer_managed: bool
+        :keyword is_private_link_resource:
+        :paramtype is_private_link_resource: bool
+        :keyword is_private_link_resource_behind_vnet:
+        :paramtype is_private_link_resource_behind_vnet: bool
+        """
+        super(UxPresenceResource, self).__init__(**kwargs)
+        self.name = name
+        self.resource_id = resource_id
+        self.resource_type = resource_type
+        self.region = region
+        self.regions = regions
+        self.subscription_id = subscription_id
+        self.resource_group_name = resource_group_name
+        self.tags = tags
+        self.is_customer_managed = is_customer_managed
+        self.is_private_link_resource = is_private_link_resource
+        self.is_private_link_resource_behind_vnet = is_private_link_resource_behind_vnet
+
+
+class UxWarmUpRequest(msrest.serialization.Model):
+    """UxWarmUpRequest.
+
+    :ivar entity_types:
+    :vartype entity_types: list[str]
+    :ivar resource_ids:
+    :vartype resource_ids: list[str]
+    """
+
+    _attribute_map = {
+        "entity_types": {"key": "entityTypes", "type": "[str]"},
+        "resource_ids": {"key": "resourceIds", "type": "[str]"},
+    }
+
+    def __init__(self, *, entity_types: Optional[List[str]] = None, resource_ids: Optional[List[str]] = None, **kwargs):
+        """
+        :keyword entity_types:
+        :paramtype entity_types: list[str]
+        :keyword resource_ids:
+        :paramtype resource_ids: list[str]
+        """
+        super(UxWarmUpRequest, self).__init__(**kwargs)
+        self.entity_types = entity_types
+        self.resource_ids = resource_ids
+
+
+class VersionedAttribute(msrest.serialization.Model):
+    """VersionedAttribute.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar name: Required.
+    :vartype name: str
+    :ivar version: Required.
+    :vartype version: str
+    """
+
+    _validation = {
+        "name": {"required": True},
+        "version": {"required": True},
+    }
+
+    _attribute_map = {
+        "name": {"key": "name", "type": "str"},
+        "version": {"key": "version", "type": "str"},
+    }
+
+    def __init__(self, *, name: str, version: str, **kwargs):
+        """
+        :keyword name: Required.
+        :paramtype name: str
+        :keyword version: Required.
+        :paramtype version: str
+        """
+        super(VersionedAttribute, self).__init__(**kwargs)
+        self.name = name
+        self.version = version
+
+
+class Webhook(msrest.serialization.Model):
+    """Webhook.
+
+    Variables are only populated by the server, and will be ignored when sending a request.
+
+    All required parameters must be populated in order to send to Azure.
+
+    :ivar webhook_type:  Has constant value: "AzureDevOps".
+    :vartype webhook_type: str
+    :ivar event_type: Required.
+    :vartype event_type: str
+    """
+
+    _validation = {
+        "webhook_type": {"required": True, "constant": True},
+        "event_type": {"required": True},
+    }
+
+    _attribute_map = {
+        "webhook_type": {"key": "webhookType", "type": "str"},
+        "event_type": {"key": "eventType", "type": "str"},
+    }
+
+    webhook_type = "AzureDevOps"
+
+    def __init__(self, *, event_type: str, **kwargs):
+        """
+        :keyword event_type: Required.
+        :paramtype event_type: str
+        """
+        super(Webhook, self).__init__(**kwargs)
+        self.event_type = event_type
+
+
+class WorkspaceContextWarmUpRequest(msrest.serialization.Model):
+    """WorkspaceContextWarmUpRequest.
+
+    :ivar discover_registries:
+    :vartype discover_registries: bool
+    """
+
+    _attribute_map = {
+        "discover_registries": {"key": "discoverRegistries", "type": "bool"},
+    }
+
+    def __init__(self, *, discover_registries: Optional[bool] = None, **kwargs):
+        """
+        :keyword discover_registries:
+        :paramtype discover_registries: bool
+        """
+        super(WorkspaceContextWarmUpRequest, self).__init__(**kwargs)
+        self.discover_registries = discover_registries
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/__init__.py
new file mode 100644
index 00000000..19ac2fed
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/__init__.py
@@ -0,0 +1,11 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._index_entities_operations import IndexEntitiesOperations
+
+__all__ = [
+    "IndexEntitiesOperations",
+]
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/_index_entities_operations.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/_index_entities_operations.py
new file mode 100644
index 00000000..c00e58ca
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/_index_entities_operations.py
@@ -0,0 +1,151 @@
+# pylint: disable=too-many-lines
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6)
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+from typing import TYPE_CHECKING
+
+from msrest import Serializer
+
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceExistsError,
+    ResourceNotFoundError,
+    map_error,
+)
+from azure.core.paging import ItemPaged
+from azure.core.pipeline import PipelineResponse
+from azure.core.pipeline.transport import HttpResponse
+from azure.core.rest import HttpRequest
+from azure.core.tracing.decorator import distributed_trace
+from azure.mgmt.core.exceptions import ARMErrorFormat
+
+from .. import models as _models
+from .._vendor import _convert_request
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from typing import Any, Callable, Dict, Iterable, Optional, TypeVar
+
+    T = TypeVar("T")
+    ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
+
+_SERIALIZER = Serializer()
+_SERIALIZER.client_side_validation = False
+# fmt: off
+
+def build_get_entites_cross_region_request(
+    **kwargs  # type: Any
+):
+    # type: (...) -> HttpRequest
+    content_type = kwargs.pop('content_type', None)  # type: Optional[str]
+
+    accept = "application/json, text/json"
+    # Construct URL
+    _url = kwargs.pop("template_url", "/ux/v1.0/entities/crossRegion")
+
+    # Construct headers
+    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
+    if content_type is not None:
+        _header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
+    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
+
+    return HttpRequest(
+        method="POST",
+        url=_url,
+        headers=_header_parameters,
+        **kwargs
+    )
+
+
+# fmt: on
+class IndexEntitiesOperations(object):
+    """IndexEntitiesOperations operations.
+
+    You should not instantiate this class directly. Instead, you should create a Client instance that
+    instantiates it for you and attaches it as an attribute.
+
+    :ivar models: Alias to model classes used in this operation group.
+    :type models: ~index_service_apis.models
+    :param client: Client for service requests.
+    :param config: Configuration of service client.
+    :param serializer: An object model serializer.
+    :param deserializer: An object model deserializer.
+    """
+
+    models = _models
+
+    def __init__(self, client, config, serializer, deserializer):
+        self._client = client
+        self._serialize = serializer
+        self._deserialize = deserializer
+        self._config = config
+
+    @distributed_trace
+    def get_entites_cross_region(
+        self,
+        body=None,  # type: Optional["_models.CrossRegionIndexEntitiesRequest"]
+        **kwargs  # type: Any
+    ):
+        # type: (...) -> Iterable["_models.IndexEntitiesResponse"]
+        """get_entites_cross_region.
+
+        :param body:
+        :type body: ~index_service_apis.models.CrossRegionIndexEntitiesRequest
+        :keyword callable cls: A custom type or function that will be passed the direct response
+        :return: An iterator like instance of either IndexEntitiesResponse or the result of
+         cls(response)
+        :rtype: ~azure.core.paging.ItemPaged[~index_service_apis.models.IndexEntitiesResponse]
+        :raises: ~azure.core.exceptions.HttpResponseError
+        """
+        content_type = kwargs.pop("content_type", "application/json-patch+json")  # type: Optional[str]
+
+        cls = kwargs.pop("cls", None)  # type: ClsType["_models.IndexEntitiesResponse"]
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}))
+
+        def prepare_request(next_link=None):
+            if body is not None:
+                body.index_entities_request.continuation_token = next_link
+                _json = self._serialize.body(body, "CrossRegionIndexEntitiesRequest")
+            else:
+                _json = None
+
+            request = build_get_entites_cross_region_request(
+                content_type=content_type,
+                json=_json,
+                template_url=self.get_entites_cross_region.metadata["url"],
+            )
+            request = _convert_request(request)
+            request.url = self._client.format_url(request.url)
+
+            return request
+
+        def extract_data(pipeline_response):
+            deserialized = self._deserialize(
+                "CrossRegionIndexEntitiesResponse", pipeline_response
+            ).index_entities_response
+            list_of_elem = deserialized.value
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            return deserialized.continuation_token, iter(list_of_elem)
+
+        def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, error_format=ARMErrorFormat)
+
+            return pipeline_response
+
+        return ItemPaged(get_next, extract_data)
+
+    get_entites_cross_region.metadata = {"url": "/ux/v1.0/entities/crossRegion"}  # type: ignore
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/py.typed b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/py.typed
new file mode 100644
index 00000000..e5aff4f8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561.
\ No newline at end of file
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_workspace_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_workspace_utils.py
new file mode 100644
index 00000000..fc6a3157
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_workspace_utils.py
@@ -0,0 +1,99 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import logging
+import random
+import uuid
+
+from azure.ai.ml._azure_environments import _get_base_url_from_metadata, _resource_to_scopes
+from azure.ai.ml._vendor.azure_resources._resource_management_client import ResourceManagementClient
+from azure.ai.ml._vendor.azure_resources.models import GenericResource
+from azure.ai.ml.constants._common import ArmConstants
+from azure.core.credentials import TokenCredential
+
+module_logger = logging.getLogger(__name__)
+
+
+def get_name_for_dependent_resource(workspace_name: str, resource_type: str) -> str:
+    alphabets_str = ""
+    for char in workspace_name.lower():
+        if char.isalpha() or char.isdigit():
+            alphabets_str = alphabets_str + char
+    rand_str = str(uuid.uuid4()).replace("-", "")
+    resource_name = alphabets_str[:8] + resource_type[:8] + rand_str
+    return resource_name[:24]
+
+
+def get_deployment_name(name: str):
+    random.seed(version=2)
+    return f"{name}-{random.randint(1, 10000000)}"
+
+
+def get_resource_group_location(credentials: TokenCredential, subscription_id: str, resource_group_name: str) -> str:
+    arm_hostname = _get_base_url_from_metadata()
+    client = ResourceManagementClient(
+        credential=credentials,
+        subscription_id=subscription_id,
+        base_url=arm_hostname,
+        api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION,
+        credential_scopes=_resource_to_scopes(arm_hostname),
+    )
+    rg = client.resource_groups.get(resource_group_name)
+    return rg.location
+
+
+def get_generic_arm_resource_by_arm_id(
+    credentials: TokenCredential,
+    subscription_id: str,
+    arm_id: str,
+    api_version: str,
+) -> GenericResource:
+    if arm_id:
+        arm_hostname = _get_base_url_from_metadata()
+        client = ResourceManagementClient(
+            credential=credentials,
+            subscription_id=subscription_id,
+            base_url=arm_hostname,
+            api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION,
+            credential_scopes=_resource_to_scopes(arm_hostname),
+        )
+        return client.resources.get_by_id(arm_id, api_version)
+    return None
+
+
+def delete_resource_by_arm_id(
+    credentials: TokenCredential,
+    subscription_id: str,
+    arm_id: str,
+    api_version: str,
+) -> None:
+    if arm_id:
+        arm_hostname = _get_base_url_from_metadata()
+        client = ResourceManagementClient(
+            credential=credentials,
+            subscription_id=subscription_id,
+            base_url=arm_hostname,
+            api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION,
+            credential_scopes=_resource_to_scopes(arm_hostname),
+        )
+        client.resources.begin_delete_by_id(arm_id, api_version)
+
+
+def get_resource_and_group_name(armstr: str) -> str:
+    return armstr.split("/")[-1], armstr.split("/")[-5]
+
+
+def get_sub_id_resource_and_group_name(armstr: str) -> str:
+    return armstr.split("/")[-7], armstr.split("/")[-1], armstr.split("/")[-5]
+
+
+def get_endpoint_parts(arm_id: str, subnet_arm_id: str) -> ():
+    arm_id_parts = arm_id.split("/")
+    subnet_id_parts = subnet_arm_id.split("/")
+    conn_name = arm_id_parts[-1]
+    subscription_id = arm_id_parts[2]
+    resource_group = arm_id_parts[4]
+    vnet_name = subnet_id_parts[-3]
+    subnet_name = subnet_id_parts[-1]
+    return conn_name, subscription_id, resource_group, vnet_name, subnet_name
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/azure_resource_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/azure_resource_utils.py
new file mode 100644
index 00000000..c038b7d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/azure_resource_utils.py
@@ -0,0 +1,79 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+
+from typing import Dict, List, Optional
+
+from azure.core.credentials import TokenCredential
+
+from .._vendor.azure_resources import ResourceManagementClient
+
+
+def get_resources_from_subscriptions(
+    strQuery: str, credential: TokenCredential, subscription_list: Optional[List[str]] = None
+):
+    # If a subscription list is passed in, use it. Otherwise, get all subscriptions
+    subsList = []
+    if subscription_list is not None:
+        subsList = subscription_list
+    else:
+        try:
+            from azure.mgmt.resource import SubscriptionClient
+        except ImportError as e:
+            raise ImportError("azure-mgmt-resource is required to get all accessible subscriptions") from e
+
+        subsClient = SubscriptionClient(credential)
+        for sub in subsClient.subscriptions.list():
+            subsList.append(sub.as_dict().get("subscription_id"))
+
+    try:
+        import azure.mgmt.resourcegraph as arg
+    except ImportError as e:
+        raise ImportError("azure-mgmt-resourcegraph is required query resources from subscriptions") from e
+
+    # Create Azure Resource Graph client and set options
+    argClient = arg.ResourceGraphClient(credential)
+    argQueryOptions = arg.models.QueryRequestOptions(result_format="objectArray")
+
+    # Create query
+    argQuery = arg.models.QueryRequest(subscriptions=subsList, query=strQuery, options=argQueryOptions)
+
+    # Allowing API version to be set is yet to be released by azure-mgmt-resourcegraph,
+    # hence the commented out code below. This is the API version Studio UX is using.
+    # return argClient.resources(argQuery, api_version="2021-03-01")
+
+    return argClient.resources(argQuery)
+
+
+def get_virtual_clusters_from_subscriptions(
+    credential: TokenCredential, subscription_list: Optional[List[str]] = None
+) -> List[Dict]:
+    # cspell:ignore tolower
+    strQuery = """resources
+    | where type == 'microsoft.machinelearningservices/virtualclusters'
+    | order by tolower(name) asc
+    | project id, subscriptionId, resourceGroup, name, location, tags, type"""
+
+    return get_resources_from_subscriptions(strQuery, credential, subscription_list).data
+
+
+def get_generic_resource_by_id(
+    arm_id: str, credential: TokenCredential, subscription_id: str, api_version: Optional[str] = None
+) -> Dict:
+    resource_client = ResourceManagementClient(credential, subscription_id)
+    generic_resource = resource_client.resources.get_by_id(arm_id, api_version)
+
+    return generic_resource.as_dict()
+
+
+def get_virtual_cluster_by_name(
+    name: str, resource_group: str, subscription_id: str, credential: TokenCredential
+) -> Dict:
+    arm_id = (
+        f"/subscriptions/{subscription_id}/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.MachineLearningServices/virtualClusters/{name}"
+    )
+
+    # This is the API version Studio UX is using.
+    return get_generic_resource_by_id(arm_id, credential, subscription_id, api_version="2021-03-01-preview")
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/utils.py
new file mode 100644
index 00000000..74b6352b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/utils.py
@@ -0,0 +1,1429 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+# pylint: disable=protected-access,too-many-lines
+import copy
+import decimal
+import hashlib
+import json
+import logging
+import os
+import random
+import re
+import string
+import sys
+import tempfile
+import time
+import warnings
+from collections import OrderedDict
+from contextlib import contextmanager, nullcontext
+from datetime import timedelta
+from functools import singledispatch, wraps
+from os import PathLike
+from pathlib import Path, PureWindowsPath
+from typing import IO, Any, AnyStr, Callable, Dict, Iterable, List, Optional, Tuple, Union
+from urllib.parse import urlparse
+from uuid import UUID
+
+import isodate
+import pydash
+import yaml
+
+from azure.ai.ml._restclient.v2022_05_01.models import ListViewType, ManagedServiceIdentity
+from azure.ai.ml._scope_dependent_operations import OperationScope
+from azure.ai.ml._utils._http_utils import HttpPipeline
+from azure.ai.ml.constants._common import (
+    AZUREML_DISABLE_CONCURRENT_COMPONENT_REGISTRATION,
+    AZUREML_DISABLE_ON_DISK_CACHE_ENV_VAR,
+    AZUREML_INTERNAL_COMPONENTS_ENV_VAR,
+    AZUREML_INTERNAL_COMPONENTS_SCHEMA_PREFIX,
+    AZUREML_PRIVATE_FEATURES_ENV_VAR,
+    CommonYamlFields,
+    DefaultOpenEncoding,
+    WorkspaceDiscoveryUrlKey,
+)
+from azure.ai.ml.exceptions import MlException
+from azure.core.pipeline.policies import RetryPolicy
+
+module_logger = logging.getLogger(__name__)
+
+DEVELOPER_URL_MFE_ENV_VAR = "AZUREML_DEV_URL_MFE"
+
+# Prefix used when hitting MFE skipping ARM
+MFE_PATH_PREFIX = "/mferp/managementfrontend"
+
+
+def _get_mfe_url_override() -> Optional[str]:
+    return os.getenv(DEVELOPER_URL_MFE_ENV_VAR)
+
+
+def _is_https_url(url: str) -> Union[bool, str]:
+    if url:
+        return url.lower().startswith("https")
+    return False
+
+
+def _csv_parser(text: Optional[str], convert: Callable) -> Optional[str]:
+    if not text:
+        return None
+    if "," in text:
+        return ",".join(convert(t.strip()) for t in text.split(","))
+
+    return convert(text)
+
+
+def _snake_to_pascal_convert(text: str) -> str:
+    return string.capwords(text.replace("_", " ")).replace(" ", "")
+
+
+def snake_to_pascal(text: Optional[str]) -> str:
+    """Convert snake name to pascal.
+
+    :param text: String to convert
+    :type text: Optional[str]
+    :return:
+        * None if text is None
+        * Converted text from snake_case to PascalCase
+    :rtype: Optional[str]
+    """
+    return _csv_parser(text, _snake_to_pascal_convert)
+
+
+def snake_to_kebab(text: Optional[str]) -> Optional[str]:
+    """Convert snake name to kebab.
+
+    :param text: String to convert
+    :type text: Optional[str]
+    :return:
+        * None if text is None
+        * Converted text from snake_case to kebab-case
+    :rtype: Optional[str]
+    """
+    if text:
+        return re.sub("_", "-", text)
+    return None
+
+
+# https://stackoverflow.com/questions/1175208
+# This works for pascal to snake as well
+def _camel_to_snake_convert(text: str) -> str:
+    text = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", text)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", text).lower()
+
+
+def camel_to_snake(text: str) -> Optional[str]:
+    """Convert camel name to snake.
+
+     :param text: String to convert
+     :type text: str
+     :return:
+        * None if text is None
+        * Converted text from camelCase to snake_case
+    :rtype: Optional[str]
+    """
+    return _csv_parser(text, _camel_to_snake_convert)
+
+
+# This is snake to camel back which is different from snake to camel
+# https://stackoverflow.com/questions/19053707
+def snake_to_camel(text: Optional[str]) -> Optional[str]:
+    """Convert snake name to camel.
+
+    :param text: String to convert
+    :type text: Optional[str]
+    :return:
+       * None if text is None
+       * Converted text from snake_case to camelCase
+    :rtype: Optional[str]
+    """
+    if text:
+        return re.sub("_([a-zA-Z0-9])", lambda m: m.group(1).upper(), text)
+    return None
+
+
+# This is real snake to camel
+def _snake_to_camel(name):
+    return re.sub(r"(?:^|_)([a-z])", lambda x: x.group(1).upper(), name)
+
+
+def float_to_str(f):
+    """Convert a float to a string without scientific notation.
+
+    :param f: Float to convert
+    :type f: float
+    :return: String representation of the float
+    :rtype: str
+    """
+    with decimal.localcontext() as ctx:
+        ctx.prec = 20  # Support up to 20 significant figures.
+        float_as_dec = ctx.create_decimal(repr(f))
+        return format(float_as_dec, "f")
+
+
+def create_requests_pipeline_with_retry(*, requests_pipeline: HttpPipeline, retries: int = 3) -> HttpPipeline:
+    """Creates an HttpPipeline that reuses the same configuration as the supplied pipeline (including the transport),
+    but overwrites the retry policy.
+
+    :keyword requests_pipeline: Pipeline to base new one off of.
+    :paramtype requests_pipeline: HttpPipeline
+    :keyword retries: Number of retries. Defaults to 3.
+    :paramtype retries: int
+    :return: Pipeline identical to provided one, except with a new retry policy
+    :rtype: HttpPipeline
+    """
+    return requests_pipeline.with_policies(retry_policy=get_retry_policy(num_retry=retries))
+
+
+def get_retry_policy(num_retry: int = 3) -> RetryPolicy:
+    """Retrieves a retry policy to use in an azure.core.pipeline.Pipeline
+
+    :param num_retry: The number of retries
+    :type num_retry: int
+    :return: Returns the msrest or requests REST client retry policy.
+    :rtype: RetryPolicy
+    """
+    status_forcelist = [413, 429, 500, 502, 503, 504]
+    backoff_factor = 0.4
+    return RetryPolicy(
+        retry_total=num_retry,
+        retry_read=num_retry,
+        retry_connect=num_retry,
+        retry_backoff_factor=backoff_factor,
+        retry_on_status_codes=status_forcelist,
+    )
+
+
+def download_text_from_url(
+    source_uri: str,
+    requests_pipeline: HttpPipeline,
+    timeout: Optional[Union[float, Tuple[float, float]]] = None,
+) -> str:
+    """Downloads the content from an URL.
+
+    :param source_uri: URI to download
+    :type source_uri: str
+    :param requests_pipeline:  Used to send the request
+    :type requests_pipeline: HttpPipeline
+    :param timeout: One of
+      * float that specifies the connect and read time outs
+      * a 2-tuple that specifies the connect and read time out in that order
+    :type timeout: Union[float, Tuple[float, float]]
+    :return: The Response text
+    :rtype: str
+    """
+    if not timeout:
+        timeout_params = {}
+    else:
+        connect_timeout, read_timeout = timeout if isinstance(timeout, tuple) else (timeout, timeout)
+        timeout_params = {"read_timeout": read_timeout, "connection_timeout": connect_timeout}
+
+    response = requests_pipeline.get(source_uri, **timeout_params)
+    # Match old behavior from execution service's status API.
+    if response.status_code == 404:
+        return ""
+
+    # _raise_request_error(response, "Retrieving content from " + uri)
+    return response.text()
+
+
+def load_file(file_path: str) -> str:
+    """Load a local file.
+
+    :param file_path: The relative or absolute path to the local file.
+    :type file_path: str
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if file or folder cannot be found.
+    :return: A string representation of the local file's contents.
+    :rtype: str
+    """
+    from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+
+    try:
+        with open(file_path, "r", encoding=DefaultOpenEncoding.READ) as f:
+            cfg = f.read()
+    except OSError as e:  # FileNotFoundError introduced in Python 3
+        msg = "No such file or directory: {}"
+        raise ValidationException(
+            message=msg.format(file_path),
+            no_personal_data_message=msg.format("[file_path]"),
+            error_category=ErrorCategory.USER_ERROR,
+            target=ErrorTarget.GENERAL,
+            error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND,
+        ) from e
+    return cfg
+
+
+def load_json(file_path: Optional[Union[str, os.PathLike]]) -> Dict:
+    """Load a local json file.
+
+    :param file_path: The relative or absolute path to the local file.
+    :type file_path: Union[str, os.PathLike]
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if file or folder cannot be found.
+    :return: A dictionary representation of the local file's contents.
+    :rtype: Dict
+    """
+    from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+
+    try:
+        with open(file_path, "r", encoding=DefaultOpenEncoding.READ) as f:
+            cfg = json.load(f)
+    except OSError as e:  # FileNotFoundError introduced in Python 3
+        msg = "No such file or directory: {}"
+        raise ValidationException(
+            message=msg.format(file_path),
+            no_personal_data_message=msg.format("[file_path]"),
+            error_category=ErrorCategory.USER_ERROR,
+            target=ErrorTarget.GENERAL,
+            error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND,
+        ) from e
+    return cfg
+
+
+def load_yaml(source: Optional[Union[AnyStr, PathLike, IO]]) -> Dict:
+    # null check - just return an empty dict.
+    # Certain CLI commands rely on this behavior to produce a resource
+    # via CLI, which is then populated through CLArgs.
+    """Load a local YAML file.
+
+    :param source: Either
+       * The relative or absolute path to the local file.
+       * A readable File-like object
+    :type source: Optional[Union[AnyStr, PathLike, IO]]
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if file or folder cannot be successfully loaded.
+        Details will be provided in the error message.
+    :return: A dictionary representation of the local file's contents.
+    :rtype: Dict
+    """
+    from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+
+    if source is None:
+        return {}
+
+    if isinstance(source, (str, os.PathLike)):
+        try:
+            cm = open(source, "r", encoding=DefaultOpenEncoding.READ)
+        except OSError as e:
+            msg = "No such file or directory: {}"
+            raise ValidationException(
+                message=msg.format(source),
+                no_personal_data_message=msg.format("[file_path]"),
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND,
+            ) from e
+    else:
+        # source is a subclass of IO
+        if not source.readable():
+            msg = "File Permissions Error: The already-open \n\n inputted file is not readable."
+            raise ValidationException(
+                message=msg,
+                no_personal_data_message="File Permissions error",
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.INVALID_VALUE,
+            )
+
+        cm = nullcontext(enter_result=source)
+
+    with cm as f:
+        try:
+            return yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            msg = f"Error while parsing yaml file: {source} \n\n {str(e)}"
+            raise ValidationException(
+                message=msg,
+                no_personal_data_message="Error while parsing yaml file",
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.CANNOT_PARSE,
+            ) from e
+
+
+# pylint: disable-next=docstring-missing-param
+def dump_yaml(*args, **kwargs):
+    """A thin wrapper over yaml.dump which forces `OrderedDict`s to be serialized as mappings.
+
+    Otherwise behaves identically to yaml.dump
+
+    :return: The yaml object
+    :rtype: Any
+    """
+
+    class OrderedDumper(yaml.Dumper):
+        """A modified yaml serializer that forces pyyaml to represent an OrderedDict as a mapping instead of a
+        sequence."""
+
+    OrderedDumper.add_representer(OrderedDict, yaml.representer.SafeRepresenter.represent_dict)
+    return yaml.dump(*args, Dumper=OrderedDumper, **kwargs)
+
+
+def dump_yaml_to_file(
+    dest: Optional[Union[AnyStr, PathLike, IO]],
+    data_dict: Union[OrderedDict, Dict],
+    default_flow_style=False,
+    args=None,  # pylint: disable=unused-argument
+    **kwargs,
+) -> None:
+    """Dump dictionary to a local YAML file.
+
+    :param dest: The relative or absolute path where the YAML dictionary will be dumped.
+    :type dest: Optional[Union[AnyStr, PathLike, IO]]
+    :param data_dict: Dictionary representing a YAML object
+    :type data_dict: Union[OrderedDict, Dict]
+    :param default_flow_style: Use flow style for formatting nested YAML collections
+        instead of block style. Defaults to False.
+    :type default_flow_style: bool
+    :param path: Deprecated. Use 'dest' param instead.
+    :type path: Optional[Union[AnyStr, PathLike]]
+    :param args: Deprecated.
+    :type: Any
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if object cannot be successfully dumped.
+        Details will be provided in the error message.
+    """
+    from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+    # Check for deprecated path input, either named or as first unnamed input
+    path = kwargs.pop("path", None)
+    if dest is None:
+        if path is not None:
+            dest = path
+            warnings.warn(
+                "the 'path' input for dump functions is deprecated. Please use 'dest' instead.", DeprecationWarning
+            )
+        else:
+            msg = "No dump destination provided."
+            raise ValidationException(
+                message=msg,
+                no_personal_data_message="No dump destination Provided",
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.MISSING_FIELD,
+            )
+
+    if isinstance(dest, (str, os.PathLike)):
+        try:
+            cm = open(dest, "w", encoding=DefaultOpenEncoding.WRITE)
+        except OSError as e:  # FileNotFoundError introduced in Python 3
+            msg = "No such parent folder path or not a file path: {}"
+            raise ValidationException(
+                message=msg.format(dest),
+                no_personal_data_message=msg.format("[file_path]"),
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND,
+            ) from e
+    else:
+        # dest is a subclass of IO
+        if not dest.writable():  # dest is misformatted stream or file
+            msg = "File Permissions Error: The already-open \n\n inputted file is not writable."
+            raise ValidationException(
+                message=msg,
+                no_personal_data_message="File Permissions error",
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.CANNOT_PARSE,
+            )
+        cm = nullcontext(enter_result=dest)
+
+    with cm as f:
+        try:
+            dump_yaml(data_dict, f, default_flow_style=default_flow_style)
+        except yaml.YAMLError as e:
+            msg = f"Error while parsing yaml file \n\n {str(e)}"
+            raise ValidationException(
+                message=msg,
+                no_personal_data_message="Error while parsing yaml file",
+                error_category=ErrorCategory.USER_ERROR,
+                target=ErrorTarget.GENERAL,
+                error_type=ValidationErrorType.CANNOT_PARSE,
+            ) from e
+
+
+def dict_eq(dict1: Dict[str, Any], dict2: Dict[str, Any]) -> bool:
+    """Compare two dictionaries.
+
+    :param dict1: The first dictionary
+    :type dict1: Dict[str, Any]
+    :param dict2: The second dictionary
+    :type dict2: Dict[str, Any]
+    :return: True if the two dictionaries are equal, False otherwise
+    :rtype: bool
+    """
+    if not dict1 and not dict2:
+        return True
+    return dict1 == dict2
+
+
+def xor(a: Any, b: Any) -> bool:
+    """XOR two values.
+
+    :param a: The first value
+    :type a: Any
+    :param b: The second value
+    :type b: Any
+    :return: False if the two values are both True or both False, True otherwise
+    :rtype: bool
+    """
+    return bool(a) != bool(b)
+
+
+def is_url(value: Union[PathLike, str]) -> bool:
+    """Check if a string is a valid URL.
+
+    :param value: The string to check
+    :type value: Union[PathLike, str]
+    :return: True if the string is a valid URL, False otherwise
+    :rtype: bool
+    """
+    try:
+        result = urlparse(str(value))
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False
+
+
+# Resolve an URL to long form if it is an azureml short from datastore URL, otherwise return the same value
+def resolve_short_datastore_url(value: Union[PathLike, str], workspace: OperationScope) -> str:
+    """Resolve an URL to long form if it is an azureml short from datastore URL, otherwise return the same value.
+
+    :param value: The URL to resolve
+    :type value: Union[PathLike, str]
+    :param workspace: The workspace
+    :type workspace: OperationScope
+    :return: The resolved URL
+    :rtype: str
+    """
+    from azure.ai.ml.exceptions import ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+
+    try:
+        # Check if the URL is an azureml URL
+        if urlparse(str(value)).scheme == "azureml":
+            from azure.ai.ml._utils._storage_utils import AzureMLDatastorePathUri
+
+            data_store_path_uri = AzureMLDatastorePathUri(value)
+            if data_store_path_uri.uri_type == "Datastore":
+                return AzureMLDatastorePathUri(value).to_long_uri(
+                    subscription_id=workspace.subscription_id,
+                    resource_group_name=workspace.resource_group_name,
+                    workspace_name=workspace.workspace_name,
+                )
+
+    except (ValueError, ValidationException):
+        pass
+
+    # If the URL is not an valid URL (e.g. a local path) or not an azureml URL
+    # (e.g. a http URL), just return the same value
+    return value
+
+
+def is_mlflow_uri(value: Union[PathLike, str]) -> bool:
+    """Check if a string is a valid mlflow uri.
+
+    :param value: The string to check
+    :type value: Union[PathLike, str]
+    :return: True if the string is a valid mlflow uri, False otherwise
+    :rtype: bool
+    """
+    try:
+        return urlparse(str(value)).scheme == "runs"
+    except ValueError:
+        return False
+
+
+def validate_ml_flow_folder(path: str, model_type: string) -> None:
+    """Validate that the path is a valid ml flow folder.
+
+    :param path: The path to validate
+    :type path: str
+    :param model_type: The model type
+    :type model_type: str
+    :return: No return value
+    :rtype: None
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the path is not a valid ml flow folder.
+    """
+    from azure.ai.ml.exceptions import ErrorTarget, ValidationErrorType, ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+
+    if not isinstance(path, str):
+        path = path.as_posix()
+    path_array = path.split("/")
+    if model_type != "mlflow_model" or "." not in path_array[-1]:
+        return
+    msg = "Error with path {}. Model of type mlflow_model cannot register a file."
+    raise ValidationException(
+        message=msg.format(path),
+        no_personal_data_message=msg.format("[path]"),
+        target=ErrorTarget.MODEL,
+        error_type=ValidationErrorType.INVALID_VALUE,
+    )
+
+
+# modified from: https://stackoverflow.com/a/33245493/8093897
+def is_valid_uuid(test_uuid: str) -> bool:
+    """Check if a string is a valid UUID.
+
+    :param test_uuid: The string to check
+    :type test_uuid: str
+    :return: True if the string is a valid UUID, False otherwise
+    :rtype: bool
+    """
+    try:
+        uuid_obj = UUID(test_uuid, version=4)
+    except ValueError:
+        return False
+    return str(uuid_obj) == test_uuid
+
+
+@singledispatch
+def from_iso_duration_format(duration: Optional[Any] = None) -> int:  # pylint: disable=unused-argument
+    """Convert ISO duration format to seconds.
+
+    :param duration: The duration to convert
+    :type duration: Optional[Any]
+    :return: The converted duration
+    :rtype: int
+    """
+    return None
+
+
+@from_iso_duration_format.register(str)
+def _(duration: str) -> int:
+    return int(isodate.parse_duration(duration).total_seconds())
+
+
+@from_iso_duration_format.register(timedelta)
+def _(duration: timedelta) -> int:
+    return int(duration.total_seconds())
+
+
+def to_iso_duration_format_mins(time_in_mins: Optional[Union[int, float]]) -> str:
+    """Convert minutes to ISO duration format.
+
+    :param time_in_mins: The time in minutes to convert
+    :type time_in_mins: Optional[Union[int, float]]
+    :return: The converted time in ISO duration format
+    :rtype: str
+    """
+    return isodate.duration_isoformat(timedelta(minutes=time_in_mins)) if time_in_mins else None
+
+
+def from_iso_duration_format_mins(duration: Optional[str]) -> int:
+    """Convert ISO duration format to minutes.
+
+    :param duration: The duration to convert
+    :type duration: Optional[str]
+    :return: The converted duration
+    :rtype: int
+    """
+    return int(from_iso_duration_format(duration) / 60) if duration else None
+
+
+def to_iso_duration_format(time_in_seconds: Optional[Union[int, float]]) -> str:
+    """Convert seconds to ISO duration format.
+
+    :param time_in_seconds: The time in seconds to convert
+    :type time_in_seconds: Optional[Union[int, float]]
+    :return: The converted time in ISO duration format
+    :rtype: str
+    """
+    return isodate.duration_isoformat(timedelta(seconds=time_in_seconds)) if time_in_seconds else None
+
+
+def to_iso_duration_format_ms(time_in_ms: Optional[Union[int, float]]) -> str:
+    """Convert milliseconds to ISO duration format.
+
+    :param time_in_ms: The time in milliseconds to convert
+    :type time_in_ms: Optional[Union[int, float]]
+    :return: The converted time in ISO duration format
+    :rtype: str
+    """
+    return isodate.duration_isoformat(timedelta(milliseconds=time_in_ms)) if time_in_ms else None
+
+
+def from_iso_duration_format_ms(duration: Optional[str]) -> int:
+    """Convert ISO duration format to milliseconds.
+
+    :param duration: The duration to convert
+    :type duration: Optional[str]
+    :return: The converted duration
+    :rtype: int
+    """
+    return from_iso_duration_format(duration) * 1000 if duration else None
+
+
+def to_iso_duration_format_days(time_in_days: Optional[int]) -> str:
+    """Convert days to ISO duration format.
+
+    :param time_in_days: The time in days to convert
+    :type time_in_days: Optional[int]
+    :return: The converted time in ISO duration format
+    :rtype: str
+    """
+    return isodate.duration_isoformat(timedelta(days=time_in_days)) if time_in_days else None
+
+
+@singledispatch
+def from_iso_duration_format_days(duration: Optional[Any] = None) -> int:  # pylint: disable=unused-argument
+    return None
+
+
+@from_iso_duration_format_days.register(str)
+def _(duration: str) -> int:
+    return int(isodate.parse_duration(duration).days)
+
+
+@from_iso_duration_format_days.register(timedelta)
+def _(duration: timedelta) -> int:
+    return int(duration.days)
+
+
+def _get_base_urls_from_discovery_service(
+    workspace_operations: "WorkspaceOperations", workspace_name: str, requests_pipeline: HttpPipeline
+) -> Dict[WorkspaceDiscoveryUrlKey, str]:
+    """Fetch base urls for a workspace from the discovery service.
+
+    :param WorkspaceOperations workspace_operations:
+    :param str workspace_name: The name of the workspace
+    :param HttpPipeline requests_pipeline: An HTTP pipeline to make requests with
+    :returns: A dictionary mapping url types to base urls
+    :rtype: Dict[WorkspaceDiscoveryUrlKey,str]
+    """
+    discovery_url = workspace_operations.get(workspace_name).discovery_url
+
+    return json.loads(
+        download_text_from_url(
+            discovery_url,
+            create_requests_pipeline_with_retry(requests_pipeline=requests_pipeline),
+        )
+    )
+
+
+def _get_mfe_base_url_from_discovery_service(
+    workspace_operations: Any, workspace_name: str, requests_pipeline: HttpPipeline
+) -> str:
+    all_urls = _get_base_urls_from_discovery_service(workspace_operations, workspace_name, requests_pipeline)
+    return f"{all_urls[WorkspaceDiscoveryUrlKey.API]}{MFE_PATH_PREFIX}"
+
+
+def _get_mfe_base_url_from_registry_discovery_service(
+    workspace_operations: Any, workspace_name: str, requests_pipeline: HttpPipeline
+) -> str:
+    all_urls = _get_base_urls_from_discovery_service(workspace_operations, workspace_name, requests_pipeline)
+    return all_urls[WorkspaceDiscoveryUrlKey.API]
+
+
+def _get_workspace_base_url(workspace_operations: Any, workspace_name: str, requests_pipeline: HttpPipeline) -> str:
+    all_urls = _get_base_urls_from_discovery_service(workspace_operations, workspace_name, requests_pipeline)
+    return all_urls[WorkspaceDiscoveryUrlKey.API]
+
+
+def _get_mfe_base_url_from_batch_endpoint(endpoint: "BatchEndpoint") -> str:
+    return endpoint.scoring_uri.split("/subscriptions/")[0]
+
+
+# Allows to use a modified client with a provided url
+@contextmanager
+def modified_operation_client(operation_to_modify, url_to_use):
+    """Modify the operation client to use a different url.
+
+    :param operation_to_modify: The operation to modify
+    :type operation_to_modify: Any
+    :param url_to_use: The url to use
+    :type url_to_use: str
+    :return: The modified operation
+    :rtype: Any
+    """
+    original_api_base_url = None
+    try:
+        # Modify the operation
+        if url_to_use:
+            original_api_base_url = operation_to_modify._client._base_url
+            operation_to_modify._client._base_url = url_to_use
+        yield
+    finally:
+        # Undo the modification
+        if original_api_base_url:
+            operation_to_modify._client._base_url = original_api_base_url
+
+
+def from_iso_duration_format_min_sec(duration: Optional[str]) -> str:
+    """Convert ISO duration format to min:sec format.
+
+    :param duration: The duration to convert
+    :type duration: Optional[str]
+    :return: The converted duration
+    :rtype: str
+    """
+    return duration.split(".")[0].replace("PT", "").replace("M", "m ") + "s"
+
+
+def hash_dict(items: Dict[str, Any], keys_to_omit: Optional[Iterable[str]] = None) -> str:
+    """Return hash GUID of a dictionary except keys_to_omit.
+
+    :param items: The dict to hash
+    :type items: Dict[str, Any]
+    :param keys_to_omit: Keys to omit before hashing
+    :type keys_to_omit: Optional[Iterable[str]]
+    :return: The hash GUID of the dictionary
+    :rtype: str
+    """
+    if keys_to_omit is None:
+        keys_to_omit = []
+    items = pydash.omit(items, keys_to_omit)
+    # serialize dict with order so same dict will have same content
+    serialized_component_interface = json.dumps(items, sort_keys=True)
+    object_hash = hashlib.md5()  # nosec
+    object_hash.update(serialized_component_interface.encode("utf-8"))
+    return str(UUID(object_hash.hexdigest()))
+
+
+def convert_identity_dict(
+    identity: Optional[ManagedServiceIdentity] = None,
+) -> ManagedServiceIdentity:
+    """Convert identity to the right format.
+
+    :param identity: The identity to convert
+    :type identity: Optional[ManagedServiceIdentity]
+    :return: The converted identity
+    :rtype: ManagedServiceIdentity
+    """
+    if identity:
+        if identity.type.lower() in ("system_assigned", "none"):
+            identity = ManagedServiceIdentity(type="SystemAssigned")
+        else:
+            if identity.user_assigned_identities:
+                if isinstance(identity.user_assigned_identities, dict):  # if the identity is already in right format
+                    return identity
+                ids = {}
+                for id in identity.user_assigned_identities:  # pylint: disable=redefined-builtin
+                    ids[id["resource_id"]] = {}
+                identity.user_assigned_identities = ids
+                identity.type = snake_to_camel(identity.type)
+    else:
+        identity = ManagedServiceIdentity(type="SystemAssigned")
+    return identity
+
+
+def strip_double_curly(io_binding_val: str) -> str:
+    """Strip double curly brackets from a string.
+
+    :param io_binding_val: The string to strip
+    :type io_binding_val: str
+    :return: The string with double curly brackets stripped
+    :rtype: str
+    """
+    return io_binding_val.replace("${{", "").replace("}}", "")
+
+
+def append_double_curly(io_binding_val: str) -> str:
+    """Append double curly brackets to a string.
+
+    :param io_binding_val: The string to append to
+    :type io_binding_val: str
+    :return: The string with double curly brackets appended
+    :rtype: str
+    """
+    return f"${{{{{io_binding_val}}}}}"
+
+
+def map_single_brackets_and_warn(command: str) -> str:
+    """Map single brackets to double brackets and warn if found.
+
+    :param command: The command to map
+    :type command: str
+    :return: The mapped command
+    :rtype: str
+    """
+
+    def _check_for_parameter(param_prefix: str, command_string: str) -> Tuple[bool, str]:
+        template_prefix = r"(?<!\{)\{"
+        template_suffix = r"\.([^}]*)\}(?!\})"
+        template = template_prefix + param_prefix + template_suffix
+        should_warn = False
+        if bool(re.search(template, command_string)):
+            should_warn = True
+            command_string = re.sub(template, r"${{" + param_prefix + r".\g<1>}}", command_string)
+        return (should_warn, command_string)
+
+    input_warn, command = _check_for_parameter("inputs", command)
+    output_warn, command = _check_for_parameter("outputs", command)
+    sweep_warn, command = _check_for_parameter("search_space", command)
+    if input_warn or output_warn or sweep_warn:
+        module_logger.warning("Use of {} for parameters is deprecated, instead use ${{}}.")
+    return command
+
+
+def transform_dict_keys(data: Dict[str, Any], casing_transform: Callable[[str], str]) -> Dict[str, Any]:
+    """Convert all keys of a nested dictionary according to the passed casing_transform function.
+
+    :param data: The data to transform
+    :type data: Dict[str, Any]
+    :param casing_transform: A callable applied to all keys in data
+    :type casing_transform: Callable[[str], str]
+    :return: A dictionary with transformed keys
+    :rtype: dict
+    """
+    return {
+        casing_transform(key): transform_dict_keys(val, casing_transform) if isinstance(val, dict) else val
+        for key, val in data.items()
+    }
+
+
+def merge_dict(origin, delta, dep=0) -> dict:
+    """Merge two dicts recursively.
+    Note that the function will return a copy of the origin dict if the depth of the recursion is 0.
+
+    :param origin: The original dictionary
+    :type origin: dict
+    :param delta: The delta dictionary
+    :type delta: dict
+    :param dep: The depth of the recursion
+    :type dep: int
+    :return: The merged dictionary
+    :rtype: dict
+    """
+    result = copy.deepcopy(origin) if dep == 0 else origin
+    for key, val in delta.items():
+        origin_val = origin.get(key)
+        # Merge delta dict with original dict
+        if isinstance(origin_val, dict) and isinstance(val, dict):
+            result[key] = merge_dict(origin_val, val, dep + 1)
+            continue
+        result[key] = copy.deepcopy(val)
+    return result
+
+
+def retry(
+    exceptions: Union[Tuple[Exception], Exception],
+    failure_msg: str,
+    logger: Any,
+    max_attempts: int = 1,
+    delay_multiplier: int = 0.25,
+) -> Callable:
+    """Retry a function if it fails.
+
+    :param exceptions: Exceptions to retry on.
+    :type exceptions: Union[Tuple[Exception], Exception]
+    :param failure_msg: Message to log on failure.
+    :type failure_msg: str
+    :param logger: Logger to use.
+    :type logger: Any
+    :param max_attempts: Maximum number of attempts.
+    :type max_attempts: int
+    :param delay_multiplier: Multiplier for delay between attempts.
+    :type delay_multiplier: int
+    :return: Decorated function.
+    :rtype: Callable
+    """
+
+    def retry_decorator(f):
+        @wraps(f)
+        def func_with_retries(*args, **kwargs):  # pylint: disable=inconsistent-return-statements
+            tries = max_attempts + 1
+            counter = 1
+            while tries > 1:
+                delay = delay_multiplier * 2**counter + random.uniform(0, 1)
+                try:
+                    return f(*args, **kwargs)
+                except exceptions as e:
+                    tries -= 1
+                    counter += 1
+                    if tries == 1:
+                        logger.warning(failure_msg)
+                        raise e
+                    logger.info(f"Operation failed. Retrying in {delay} seconds.")
+                    time.sleep(delay)
+
+        return func_with_retries
+
+    return retry_decorator
+
+
+def get_list_view_type(include_archived: bool, archived_only: bool) -> ListViewType:
+    """Get the list view type based on the include_archived and archived_only flags.
+
+    :param include_archived: Whether to include archived items.
+    :type include_archived: bool
+    :param archived_only: Whether to only include archived items.
+    :type archived_only: bool
+    :return: The list view type.
+    :rtype: ListViewType
+    """
+    if include_archived and archived_only:
+        msg = "Cannot provide both archived-only and include-archived."
+        raise MlException(message=msg, no_personal_data_message=msg)
+    if include_archived:
+        return ListViewType.ALL
+    if archived_only:
+        return ListViewType.ARCHIVED_ONLY
+    return ListViewType.ACTIVE_ONLY
+
+
+def is_data_binding_expression(
+    value: str, binding_prefix: Union[str, List[str]] = "", is_singular: bool = True
+) -> bool:
+    """Check if a value is a data-binding expression with specific binding target(prefix). Note that the function will
+    return False if the value is not a str. For example, if binding_prefix is ["parent", "jobs"], then input_value is a
+    data-binding expression only if the binding target starts with "parent.jobs", like "${{parent.jobs.xxx}}" if
+    is_singular is False, return True even if input_value includes non-binding part or multiple binding targets, like
+    "${{parent.jobs.xxx}}_extra" and "${{parent.jobs.xxx}}_{{parent.jobs.xxx}}".
+
+    :param value: Value to check.
+    :type value: str
+    :param binding_prefix: Prefix to check for.
+    :type binding_prefix: Union[str, List[str]]
+    :param is_singular: should the value be a singular data-binding expression, like "${{parent.jobs.xxx}}".
+    :type is_singular: bool
+    :return: True if the value is a data-binding expression, False otherwise.
+    :rtype: bool
+    """
+    return len(get_all_data_binding_expressions(value, binding_prefix, is_singular)) > 0
+
+
+def get_all_data_binding_expressions(
+    value: str, binding_prefix: Union[str, List[str]] = "", is_singular: bool = True
+) -> List[str]:
+    """Get all data-binding expressions in a value with specific binding target(prefix). Note that the function will
+    return an empty list if the value is not a str.
+
+    :param value: Value to extract.
+    :type value: str
+    :param binding_prefix: Prefix to filter.
+    :type binding_prefix: Union[str, List[str]]
+    :param is_singular: should the value be a singular data-binding expression, like "${{parent.jobs.xxx}}".
+    :type is_singular: bool
+    :return: list of data-binding expressions.
+    :rtype: List[str]
+    """
+    if isinstance(binding_prefix, str):
+        binding_prefix = [binding_prefix]
+    if isinstance(value, str):
+        target_regex = r"\$\{\{\s*(" + "\\.".join(binding_prefix) + r"\S*?)\s*\}\}"
+        if is_singular:
+            target_regex = "^" + target_regex + "$"
+        return re.findall(target_regex, value)
+    return []
+
+
+def is_private_preview_enabled():
+    """Check if private preview features are enabled.
+
+    :return: True if private preview features are enabled, False otherwise.
+    :rtype: bool
+    """
+    return os.getenv(AZUREML_PRIVATE_FEATURES_ENV_VAR) in ["True", "true", True]
+
+
+def is_bytecode_optimization_enabled():
+    """Check if bytecode optimization is enabled:
+    1) bytecode package is installed
+    2) private preview is enabled
+    3) python version is between 3.6 and 3.11
+
+    :return: True if bytecode optimization is enabled, False otherwise.
+    :rtype: bool
+    """
+    try:
+        import bytecode  # pylint: disable=unused-import
+
+        return is_private_preview_enabled() and (3, 6) < sys.version_info < (3, 12)
+    except ImportError:
+        return False
+
+
+def is_on_disk_cache_enabled():
+    """Check if on-disk cache for component registrations in pipeline submission is enabled.
+
+    :return: True if on-disk cache is enabled, False otherwise.
+    :rtype: bool
+    """
+    return os.getenv(AZUREML_DISABLE_ON_DISK_CACHE_ENV_VAR) not in ["True", "true", True]
+
+
+def is_concurrent_component_registration_enabled():  # pylint: disable=name-too-long
+    """Check if concurrent component registrations in pipeline submission is enabled.
+
+    :return: True if concurrent component registration is enabled, False otherwise.
+    :rtype: bool
+    """
+    return os.getenv(AZUREML_DISABLE_CONCURRENT_COMPONENT_REGISTRATION) not in ["True", "true", True]
+
+
+def _is_internal_components_enabled():
+    return os.getenv(AZUREML_INTERNAL_COMPONENTS_ENV_VAR) in ["True", "true", True]
+
+
+def try_enable_internal_components(*, force=False) -> bool:
+    """Try to enable internal components for the current process. This is the only function outside _internal that
+    references _internal.
+
+    :keyword force: Force enable internal components even if enabled before.
+    :type force: bool
+    :return: True if internal components are enabled, False otherwise.
+    :rtype: bool
+    """
+    if _is_internal_components_enabled():
+        from azure.ai.ml._internal import enable_internal_components_in_pipeline
+
+        enable_internal_components_in_pipeline(force=force)
+
+        return True
+    return False
+
+
+def is_internal_component_data(data: Dict[str, Any], *, raise_if_not_enabled: bool = False) -> bool:
+    """Check if the data is an internal component data by checking schema url prefix.
+
+    :param data: The data to check.
+    :type data: Dict[str, Any]
+    :keyword raise_if_not_enabled: Raise exception if the data is an internal component data but
+        internal components is not enabled.
+    :type raise_if_not_enabled: bool
+    :return: True if the data is an internal component data, False otherwise.
+    :rtype: bool
+    :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the data is an internal component data but
+        internal components is not enabled.
+    """
+    from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException
+
+    # These imports can't be placed in at top file level because it will cause a circular import in
+    # exceptions.py via _get_mfe_url_override
+
+    schema = data.get(CommonYamlFields.SCHEMA, None)
+
+    if schema is None or not isinstance(schema, str):
+        return False
+
+    if not schema.startswith(AZUREML_INTERNAL_COMPONENTS_SCHEMA_PREFIX):
+        return False
+
+    if not _is_internal_components_enabled() and raise_if_not_enabled:
+        no_personal_data_message = (
+            f"Internal components is a private feature in v2, please set environment variable "
+            f"{AZUREML_INTERNAL_COMPONENTS_ENV_VAR} to true to use it."
+        )
+        msg = f"Detected schema url {schema}. {no_personal_data_message}"
+        raise ValidationException(
+            message=msg,
+            target=ErrorTarget.COMPONENT,
+            error_type=ValidationErrorType.INVALID_VALUE,
+            no_personal_data_message=no_personal_data_message,
+            error_category=ErrorCategory.USER_ERROR,
+        )
+
+    return True
+
+
+def is_valid_node_name(name: str) -> bool:
+    """Check if `name` is a valid node name
+
+    :param name: A node name
+    :type name: str
+    :return: Return True if the string is a valid Python identifier in lower ASCII range, False otherwise.
+    :rtype: bool
+    """
+    return isinstance(name, str) and name.isidentifier() and re.fullmatch(r"^[a-z_][a-z\d_]*", name) is not None
+
+
+def parse_args_description_from_docstring(docstring: str) -> Dict[str, str]:
+    """Return arg descriptions in docstring with google style.
+
+    e.g.
+        docstring =
+            '''
+            A pipeline with detailed docstring, including descriptions for inputs and outputs.
+
+            In this pipeline docstring, there are descriptions for inputs and outputs
+            Input/Output descriptions can infer from descriptions here.
+
+            Args:
+                job_in_path: a path parameter
+                job_in_number: a number parameter
+                                with multi-line description
+                job_in_int (int): a int parameter
+
+            Other docstring xxxxxx
+                random_key: random_value
+            '''
+
+    return dict:
+            args = {
+                'job_in_path': 'a path parameter',
+                'job_in_number': 'a number parameter with multi-line description',
+                'job_in_int': 'a int parameter'
+            }
+
+    :param docstring: A Google-style docstring
+    :type docstring: str
+    :return: A map of parameter names to parameter descriptions
+    :rtype: Dict[str, str]
+    """
+    args = {}
+    if not isinstance(docstring, str):
+        return args
+    lines = [line.strip() for line in docstring.splitlines()]
+    for index, line in enumerate(lines):
+        if line.lower() == "args:":
+            args_region = lines[index + 1 :]
+            args_line_end = args_region.index("") if "" in args_region else len(args_region)
+            args_region = args_region[0:args_line_end]
+            while len(args_region) > 0 and ":" in args_region[0]:
+                arg_line = args_region[0]
+                colon_index = arg_line.index(":")
+                arg, description = (
+                    arg_line[0:colon_index].strip(),
+                    arg_line[colon_index + 1 :].strip(),
+                )
+                # handle case like "param (float) : xxx"
+                if "(" in arg:
+                    arg = arg[0 : arg.index("(")].strip()
+                args[arg] = description
+                args_region.pop(0)
+                # handle multi-line description, assuming description has no colon inside.
+                while len(args_region) > 0 and ":" not in args_region[0]:
+                    args[arg] += " " + args_region[0]
+                    args_region.pop(0)
+    return args
+
+
+def convert_windows_path_to_unix(path: Union[str, PathLike]) -> str:
+    """Convert a Windows path to a Unix path.
+
+    :param path: A Windows path
+    :type path: Union[str, os.PathLike]
+    :return: A Unix path
+    :rtype: str
+    """
+    return PureWindowsPath(path).as_posix()
+
+
+def _is_user_error_from_status_code(http_status_code):
+    return 400 <= http_status_code < 500
+
+
+def _str_to_bool(s: str) -> bool:
+    """Converts a string to a boolean
+
+    Can be used as a type for argument in argparse, return argument's boolean value according to it's literal value.
+
+    :param s: The string to convert
+    :type s: str
+    :return: True if s is "true" (case-insensitive), otherwise returns False.
+    :rtype: bool
+    """
+    if not isinstance(s, str):
+        return False
+    return s.lower() == "true"
+
+
+def _is_user_error_from_exception_type(e: Optional[Exception]) -> bool:
+    """Determine whether if an exception is user error from it's exception type.
+
+    :param e: An exception
+    :type e: Optional[Exception]
+    :return: True if exception is a user error
+    :rtype: bool
+    """
+    # Connection error happens on user's network failure, should be user error.
+    # For OSError/IOError with error no 28: "No space left on device" should be sdk user error
+    return isinstance(e, (ConnectionError, KeyboardInterrupt)) or (isinstance(e, (IOError, OSError)) and e.errno == 28)
+
+
+class DockerProxy:
+    """A proxy class for docker module. It will raise a more user-friendly error message if docker module is not
+    installed.
+    """
+
+    def __getattribute__(self, name: str) -> Any:
+        try:
+            import docker
+
+            return getattr(docker, name)
+        except ModuleNotFoundError as e:
+            msg = "Please install docker in the current python environment with `pip install docker` and try again."
+            raise MlException(message=msg, no_personal_data_message=msg) from e
+
+
+def get_all_enum_values_iter(enum_type: type) -> Iterable[Any]:
+    """Get all values of an enum type.
+
+    :param enum_type: An "enum" (not necessary enum.Enum)
+    :type enum_type: Type
+    :return: An iterable of all of the attributes of `enum_type`
+    :rtype: Iterable[Any]
+    """
+    for key in dir(enum_type):
+        if not key.startswith("_"):
+            yield getattr(enum_type, key)
+
+
+def write_to_shared_file(file_path: Union[str, PathLike], content: str):
+    """Open file with specific mode and return the file object.
+
+    :param file_path: Path to the file.
+    :type file_path: Union[str, os.PathLike]
+    :param content: Content to write to the file.
+    :type content: str
+    """
+    with open(file_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
+        f.write(content)
+
+    # share_mode means read/write for owner, group and others
+    share_mode, mode_mask = 0o666, 0o777
+    if os.stat(file_path).st_mode & mode_mask != share_mode:
+        try:
+            os.chmod(file_path, share_mode)
+        except PermissionError:
+            pass
+
+
+def _get_valid_dot_keys_with_wildcard_impl(
+    left_reversed_parts, root, *, validate_func=None, cur_node=None, processed_parts=None
+) -> List[str]:
+    if len(left_reversed_parts) == 0:
+        if validate_func is None or validate_func(root, processed_parts):
+            return [".".join(processed_parts)]
+        return []
+
+    if cur_node is None:
+        cur_node = root
+    if not isinstance(cur_node, dict):
+        return []
+    if processed_parts is None:
+        processed_parts = []
+
+    key: str = left_reversed_parts.pop()
+    result = []
+    if key == "*":
+        for next_key in cur_node:
+            if not isinstance(next_key, str):
+                continue
+            processed_parts.append(next_key)
+            result.extend(
+                _get_valid_dot_keys_with_wildcard_impl(
+                    left_reversed_parts,
+                    root,
+                    validate_func=validate_func,
+                    cur_node=cur_node[next_key],
+                    processed_parts=processed_parts,
+                )
+            )
+            processed_parts.pop()
+    elif key in cur_node:
+        processed_parts.append(key)
+        result = _get_valid_dot_keys_with_wildcard_impl(
+            left_reversed_parts,
+            root,
+            validate_func=validate_func,
+            cur_node=cur_node[key],
+            processed_parts=processed_parts,
+        )
+        processed_parts.pop()
+
+    left_reversed_parts.append(key)
+    return result
+
+
+def get_valid_dot_keys_with_wildcard(
+    root: Dict[str, Any],
+    dot_key_wildcard: str,
+    *,
+    validate_func: Optional[Callable[[List[str], Dict[str, Any]], bool]] = None,
+) -> List[str]:
+    """Get all valid dot keys with wildcard. Only "x.*.x" and "x.*" is supported for now.
+
+    A valid dot key should satisfy the following conditions:
+    1) It should be a valid dot key in the root node.
+    2) It should satisfy the validation function.
+
+    :param root: Root node.
+    :type root: Dict[str, Any]
+    :param dot_key_wildcard: Dot key with wildcard, e.g. "a.*.c".
+    :type dot_key_wildcard: str
+    :keyword validate_func: Validation function. It takes two parameters: the root node and the dot key parts.
+    If None, no validation will be performed.
+    :paramtype validate_func: Optional[Callable[[List[str], Dict[str, Any]], bool]]
+    :return: List of valid dot keys.
+    :rtype: List[str]
+    """
+    left_reversed_parts = dot_key_wildcard.split(".")[::-1]
+    return _get_valid_dot_keys_with_wildcard_impl(left_reversed_parts, root, validate_func=validate_func)
+
+
+def get_base_directory_for_cache() -> Path:
+    """Get the base directory for cache files.
+
+    :return: The base directory for cache files.
+    :rtype: Path
+    """
+    return Path(tempfile.gettempdir()).joinpath("azure-ai-ml")
+
+
+def get_versioned_base_directory_for_cache() -> Path:
+    """Get the base directory for cache files of current version of azure-ai-ml.
+    Cache files of different versions will be stored in different directories.
+
+    :return: The base directory for cache files of current version of azure-ai-ml.
+    :rtype: Path
+    """
+    # import here to avoid circular import
+    from azure.ai.ml._version import VERSION
+
+    return get_base_directory_for_cache().joinpath(VERSION)
+
+
+# pylint: disable-next=name-too-long
+def get_resource_and_group_name_from_resource_id(armstr: str) -> str:
+    if armstr.find("/") == -1:
+        return armstr, None
+    return armstr.split("/")[-1], armstr.split("/")[-5]
+
+
+# pylint: disable-next=name-too-long
+def get_resource_group_name_from_resource_group_id(armstr: str) -> str:
+    if armstr.find("/") == -1:
+        return armstr
+    return armstr.split("/")[-1]
+
+
+def extract_name_and_version(azureml_id: str) -> Dict[str, str]:
+    """Extract name and version from azureml id.
+
+    :param azureml_id: AzureML id.
+    :type azureml_id: str
+    :return: A dict of name and version.
+    :rtype: Dict[str, str]
+    """
+    if not isinstance(azureml_id, str):
+        raise ValueError("azureml_id should be a string but got {}: {}.".format(type(azureml_id), azureml_id))
+    if azureml_id.count(":") != 1:
+        raise ValueError("azureml_id should be in the format of name:version but got {}.".format(azureml_id))
+    name, version = azureml_id.split(":")
+    return {
+        "name": name,
+        "version": version,
+    }
+
+
+def _get_evaluator_properties():
+    return {"is-promptflow": "true", "is-evaluator": "true"}
+
+
+def _is_evaluator(properties: Dict[str, str]) -> bool:
+    return properties.get("is-evaluator") == "true" and properties.get("is-promptflow") == "true"