diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/CHANGELOG.md b/sdk/healthinsights/azure-healthinsights-radiologyinsights/CHANGELOG.md
new file mode 100644
index 0000000000000..628743d283a92
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/CHANGELOG.md
@@ -0,0 +1,5 @@
+# Release History
+
+## 1.0.0b1 (1970-01-01)
+
+- Initial version
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/LICENSE b/sdk/healthinsights/azure-healthinsights-radiologyinsights/LICENSE
new file mode 100644
index 0000000000000..63447fd8bbbf7
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+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.
\ No newline at end of file
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/MANIFEST.in b/sdk/healthinsights/azure-healthinsights-radiologyinsights/MANIFEST.in
new file mode 100644
index 0000000000000..d2fd55d2d2adf
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/MANIFEST.in
@@ -0,0 +1,7 @@
+include *.md
+include LICENSE
+include azure/healthinsights/radiologyinsights/py.typed
+recursive-include tests *.py
+recursive-include samples *.py *.md
+include azure/__init__.py
+include azure/healthinsights/__init__.py
\ No newline at end of file
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/README.md b/sdk/healthinsights/azure-healthinsights-radiologyinsights/README.md
new file mode 100644
index 0000000000000..ffada5b551e29
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/README.md
@@ -0,0 +1,45 @@
+
+
+# Azure Health Insights - Radiology Insights client library for Python
+<!-- write necessary description of service -->
+
+## Getting started
+
+### Installating the package
+
+```bash
+python -m pip install azure-healthinsights-radiologyinsights
+```
+
+#### Prequisites
+
+- Python 3.8 or later is required to use this package.
+- You need an [Azure subscription][azure_sub] to use this package.
+- An existing Azure Health Insights - Radiology Insights instance.
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require
+you to agree to a Contributor License Agreement (CLA) declaring that you have
+the right to, and actually do, grant us the rights to use your contribution.
+For details, visit https://cla.microsoft.com.
+
+When you submit a pull request, a CLA-bot will automatically determine whether
+you need to provide a CLA and decorate the PR appropriately (e.g., label,
+comment). Simply follow the instructions provided by the bot. You will only
+need to do this once across all repos using our CLA.
+
+This project has adopted the
+[Microsoft Open Source Code of Conduct][code_of_conduct]. For more information,
+see the Code of Conduct FAQ or contact opencode@microsoft.com with any
+additional questions or comments.
+
+<!-- LINKS -->
+[code_of_conduct]: https://opensource.microsoft.com/codeofconduct/
+[authenticate_with_token]: https://docs.microsoft.com/azure/cognitive-services/authentication?tabs=powershell#authenticate-with-an-authentication-token
+[azure_identity_credentials]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#credentials
+[azure_identity_pip]: https://pypi.org/project/azure-identity/
+[default_azure_credential]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#defaultazurecredential
+[pip]: https://pypi.org/project/pip/
+[azure_sub]: https://azure.microsoft.com/free/
+
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/_meta.json b/sdk/healthinsights/azure-healthinsights-radiologyinsights/_meta.json
new file mode 100644
index 0000000000000..3f042862cea87
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/_meta.json
@@ -0,0 +1,6 @@
+{
+  "commit": "9ce05f612a099a0363ca952ea3fd751d71a9bf16",
+  "repository_url": "https://github.com/Azure/azure-rest-api-specs",
+  "typespec_src": "specification/ai/HealthInsights/HealthInsights.RadiologyInsights",
+  "@azure-tools/typespec-python": "0.21.0"
+}
\ No newline at end of file
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/__init__.py
new file mode 100644
index 0000000000000..d55ccad1f573f
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/__init__.py
@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/__init__.py
new file mode 100644
index 0000000000000..d55ccad1f573f
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/__init__.py
@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/__init__.py
new file mode 100644
index 0000000000000..280758827c610
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/__init__.py
@@ -0,0 +1,26 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._client import RadiologyInsightsClient
+from ._version import VERSION
+
+__version__ = VERSION
+
+try:
+    from ._patch import __all__ as _patch_all
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+except ImportError:
+    _patch_all = []
+from ._patch import patch_sdk as _patch_sdk
+
+__all__ = [
+    "RadiologyInsightsClient",
+]
+__all__.extend([p for p in _patch_all if p not in __all__])
+
+_patch_sdk()
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_client.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_client.py
new file mode 100644
index 0000000000000..b9bfb90589c8a
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_client.py
@@ -0,0 +1,99 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from copy import deepcopy
+from typing import Any
+
+from azure.core import PipelineClient
+from azure.core.credentials import AzureKeyCredential
+from azure.core.pipeline import policies
+from azure.core.rest import HttpRequest, HttpResponse
+
+from ._configuration import RadiologyInsightsClientConfiguration
+from ._operations import RadiologyInsightsClientOperationsMixin
+from ._serialization import Deserializer, Serializer
+
+
+class RadiologyInsightsClient(
+    RadiologyInsightsClientOperationsMixin
+):  # pylint: disable=client-accepts-api-version-keyword
+    """RadiologyInsightsClient.
+
+    :param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
+     https://westus2.api.cognitive.microsoft.com). Required.
+    :type endpoint: str
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.AzureKeyCredential
+    :keyword api_version: The API version to use for this operation. Default value is "2024-04-01".
+     Note that overriding this default value may result in unsupported behavior.
+    :paramtype api_version: str
+    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
+     Retry-After header is present.
+    """
+
+    def __init__(self, endpoint: str, credential: AzureKeyCredential, **kwargs: Any) -> None:
+        _endpoint = "{endpoint}/health-insights"
+        self._config = RadiologyInsightsClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
+        _policies = kwargs.pop("policies", None)
+        if _policies is None:
+            _policies = [
+                policies.RequestIdPolicy(**kwargs),
+                self._config.headers_policy,
+                self._config.user_agent_policy,
+                self._config.proxy_policy,
+                policies.ContentDecodePolicy(**kwargs),
+                self._config.redirect_policy,
+                self._config.retry_policy,
+                self._config.authentication_policy,
+                self._config.custom_hook_policy,
+                self._config.logging_policy,
+                policies.DistributedTracingPolicy(**kwargs),
+                policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+                self._config.http_logging_policy,
+            ]
+        self._client: PipelineClient = PipelineClient(base_url=_endpoint, policies=_policies, **kwargs)
+
+        self._serialize = Serializer()
+        self._deserialize = Deserializer()
+        self._serialize.client_side_validation = False
+
+    def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> 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/dpcodegen/python/send_request
+
+        :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)
+        path_format_arguments = {
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
+        }
+
+        request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> "RadiologyInsightsClient":
+        self._client.__enter__()
+        return self
+
+    def __exit__(self, *exc_details: Any) -> None:
+        self._client.__exit__(*exc_details)
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_configuration.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_configuration.py
new file mode 100644
index 0000000000000..82769f8410047
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_configuration.py
@@ -0,0 +1,61 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from typing import Any
+
+from azure.core.credentials import AzureKeyCredential
+from azure.core.pipeline import policies
+
+from ._version import VERSION
+
+
+class RadiologyInsightsClientConfiguration:  # pylint: disable=too-many-instance-attributes,name-too-long
+    """Configuration for RadiologyInsightsClient.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+
+    :param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
+     https://westus2.api.cognitive.microsoft.com). Required.
+    :type endpoint: str
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.AzureKeyCredential
+    :keyword api_version: The API version to use for this operation. Default value is "2024-04-01".
+     Note that overriding this default value may result in unsupported behavior.
+    :paramtype api_version: str
+    """
+
+    def __init__(self, endpoint: str, credential: AzureKeyCredential, **kwargs: Any) -> None:
+        api_version: str = kwargs.pop("api_version", "2024-04-01")
+
+        if endpoint is None:
+            raise ValueError("Parameter 'endpoint' must not be None.")
+        if credential is None:
+            raise ValueError("Parameter 'credential' must not be None.")
+
+        self.endpoint = endpoint
+        self.credential = credential
+        self.api_version = api_version
+        kwargs.setdefault("sdk_moniker", "healthinsights-radiologyinsights/{}".format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
+        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 policies.HttpLoggingPolicy(**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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
+        self.authentication_policy = kwargs.get("authentication_policy")
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = policies.AzureKeyCredentialPolicy(
+                self.credential, "Ocp-Apim-Subscription-Key", **kwargs
+            )
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_model_base.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_model_base.py
new file mode 100644
index 0000000000000..1ddc071517d69
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_model_base.py
@@ -0,0 +1,874 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+# pylint: disable=protected-access, arguments-differ, signature-differs, broad-except
+
+import calendar
+import decimal
+import functools
+import sys
+import logging
+import base64
+import re
+import copy
+import typing
+import enum
+import email.utils
+from datetime import datetime, date, time, timedelta, timezone
+from json import JSONEncoder
+from typing_extensions import Self
+import isodate
+from azure.core.exceptions import DeserializationError
+from azure.core import CaseInsensitiveEnumMeta
+from azure.core.pipeline import PipelineResponse
+from azure.core.serialization import _Null
+
+if sys.version_info >= (3, 9):
+    from collections.abc import MutableMapping
+else:
+    from typing import MutableMapping
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
+
+TZ_UTC = timezone.utc
+_T = typing.TypeVar("_T")
+
+
+def _timedelta_as_isostr(td: timedelta) -> str:
+    """Converts a datetime.timedelta object into an ISO 8601 formatted string, e.g. 'P4DT12H30M05S'
+
+    Function adapted from the Tin Can Python project: https://github.com/RusticiSoftware/TinCanPython
+
+    :param timedelta td: The timedelta to convert
+    :rtype: str
+    :return: ISO8601 version of this timedelta
+    """
+
+    # Split seconds to larger units
+    seconds = td.total_seconds()
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+
+    days, hours, minutes = list(map(int, (days, hours, minutes)))
+    seconds = round(seconds, 6)
+
+    # Build date
+    date_str = ""
+    if days:
+        date_str = "%sD" % days
+
+    if hours or minutes or seconds:
+        # Build time
+        time_str = "T"
+
+        # Hours
+        bigger_exists = date_str or hours
+        if bigger_exists:
+            time_str += "{:02}H".format(hours)
+
+        # Minutes
+        bigger_exists = bigger_exists or minutes
+        if bigger_exists:
+            time_str += "{:02}M".format(minutes)
+
+        # Seconds
+        try:
+            if seconds.is_integer():
+                seconds_string = "{:02}".format(int(seconds))
+            else:
+                # 9 chars long w/ leading 0, 6 digits after decimal
+                seconds_string = "%09.6f" % seconds
+                # Remove trailing zeros
+                seconds_string = seconds_string.rstrip("0")
+        except AttributeError:  # int.is_integer() raises
+            seconds_string = "{:02}".format(seconds)
+
+        time_str += "{}S".format(seconds_string)
+    else:
+        time_str = ""
+
+    return "P" + date_str + time_str
+
+
+def _serialize_bytes(o, format: typing.Optional[str] = None) -> str:
+    encoded = base64.b64encode(o).decode()
+    if format == "base64url":
+        return encoded.strip("=").replace("+", "-").replace("/", "_")
+    return encoded
+
+
+def _serialize_datetime(o, format: typing.Optional[str] = None):
+    if hasattr(o, "year") and hasattr(o, "hour"):
+        if format == "rfc7231":
+            return email.utils.format_datetime(o, usegmt=True)
+        if format == "unix-timestamp":
+            return int(calendar.timegm(o.utctimetuple()))
+
+        # astimezone() fails for naive times in Python 2.7, so make make sure o is aware (tzinfo is set)
+        if not o.tzinfo:
+            iso_formatted = o.replace(tzinfo=TZ_UTC).isoformat()
+        else:
+            iso_formatted = o.astimezone(TZ_UTC).isoformat()
+        # Replace the trailing "+00:00" UTC offset with "Z" (RFC 3339: https://www.ietf.org/rfc/rfc3339.txt)
+        return iso_formatted.replace("+00:00", "Z")
+    # Next try datetime.date or datetime.time
+    return o.isoformat()
+
+
+def _is_readonly(p):
+    try:
+        return p._visibility == ["read"]  # pylint: disable=protected-access
+    except AttributeError:
+        return False
+
+
+class SdkJSONEncoder(JSONEncoder):
+    """A JSON encoder that's capable of serializing datetime objects and bytes."""
+
+    def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optional[str] = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.exclude_readonly = exclude_readonly
+        self.format = format
+
+    def default(self, o):  # pylint: disable=too-many-return-statements
+        if _is_model(o):
+            if self.exclude_readonly:
+                readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)]
+                return {k: v for k, v in o.items() if k not in readonly_props}
+            return dict(o.items())
+        try:
+            return super(SdkJSONEncoder, self).default(o)
+        except TypeError:
+            if isinstance(o, _Null):
+                return None
+            if isinstance(o, decimal.Decimal):
+                return float(o)
+            if isinstance(o, (bytes, bytearray)):
+                return _serialize_bytes(o, self.format)
+            try:
+                # First try datetime.datetime
+                return _serialize_datetime(o, self.format)
+            except AttributeError:
+                pass
+            # Last, try datetime.timedelta
+            try:
+                return _timedelta_as_isostr(o)
+            except AttributeError:
+                # This will be raised when it hits value.total_seconds in the method above
+                pass
+            return super(SdkJSONEncoder, self).default(o)
+
+
+_VALID_DATE = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" + r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
+_VALID_RFC7231 = re.compile(
+    r"(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s"
+    r"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT"
+)
+
+
+def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
+    """Deserialize ISO-8601 formatted string into Datetime object.
+
+    :param str attr: response string to be deserialized.
+    :rtype: ~datetime.datetime
+    :returns: The datetime object from that input
+    """
+    if isinstance(attr, datetime):
+        # i'm already deserialized
+        return attr
+    attr = attr.upper()
+    match = _VALID_DATE.match(attr)
+    if not match:
+        raise ValueError("Invalid datetime string: " + attr)
+
+    check_decimal = attr.split(".")
+    if len(check_decimal) > 1:
+        decimal_str = ""
+        for digit in check_decimal[1]:
+            if digit.isdigit():
+                decimal_str += digit
+            else:
+                break
+        if len(decimal_str) > 6:
+            attr = attr.replace(decimal_str, decimal_str[0:6])
+
+    date_obj = isodate.parse_datetime(attr)
+    test_utc = date_obj.utctimetuple()
+    if test_utc.tm_year > 9999 or test_utc.tm_year < 1:
+        raise OverflowError("Hit max or min date")
+    return date_obj
+
+
+def _deserialize_datetime_rfc7231(attr: typing.Union[str, datetime]) -> datetime:
+    """Deserialize RFC7231 formatted string into Datetime object.
+
+    :param str attr: response string to be deserialized.
+    :rtype: ~datetime.datetime
+    :returns: The datetime object from that input
+    """
+    if isinstance(attr, datetime):
+        # i'm already deserialized
+        return attr
+    match = _VALID_RFC7231.match(attr)
+    if not match:
+        raise ValueError("Invalid datetime string: " + attr)
+
+    return email.utils.parsedate_to_datetime(attr)
+
+
+def _deserialize_datetime_unix_timestamp(attr: typing.Union[float, datetime]) -> datetime:
+    """Deserialize unix timestamp into Datetime object.
+
+    :param str attr: response string to be deserialized.
+    :rtype: ~datetime.datetime
+    :returns: The datetime object from that input
+    """
+    if isinstance(attr, datetime):
+        # i'm already deserialized
+        return attr
+    return datetime.fromtimestamp(attr, TZ_UTC)
+
+
+def _deserialize_date(attr: typing.Union[str, date]) -> date:
+    """Deserialize ISO-8601 formatted string into Date object.
+    :param str attr: response string to be deserialized.
+    :rtype: date
+    :returns: The date object from that input
+    """
+    # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
+    if isinstance(attr, date):
+        return attr
+    return isodate.parse_date(attr, defaultmonth=None, defaultday=None)  # type: ignore
+
+
+def _deserialize_time(attr: typing.Union[str, time]) -> time:
+    """Deserialize ISO-8601 formatted string into time object.
+
+    :param str attr: response string to be deserialized.
+    :rtype: datetime.time
+    :returns: The time object from that input
+    """
+    if isinstance(attr, time):
+        return attr
+    return isodate.parse_time(attr)
+
+
+def _deserialize_bytes(attr):
+    if isinstance(attr, (bytes, bytearray)):
+        return attr
+    return bytes(base64.b64decode(attr))
+
+
+def _deserialize_bytes_base64(attr):
+    if isinstance(attr, (bytes, bytearray)):
+        return attr
+    padding = "=" * (3 - (len(attr) + 3) % 4)  # type: ignore
+    attr = attr + padding  # type: ignore
+    encoded = attr.replace("-", "+").replace("_", "/")
+    return bytes(base64.b64decode(encoded))
+
+
+def _deserialize_duration(attr):
+    if isinstance(attr, timedelta):
+        return attr
+    return isodate.parse_duration(attr)
+
+
+def _deserialize_decimal(attr):
+    if isinstance(attr, decimal.Decimal):
+        return attr
+    return decimal.Decimal(str(attr))
+
+
+_DESERIALIZE_MAPPING = {
+    datetime: _deserialize_datetime,
+    date: _deserialize_date,
+    time: _deserialize_time,
+    bytes: _deserialize_bytes,
+    bytearray: _deserialize_bytes,
+    timedelta: _deserialize_duration,
+    typing.Any: lambda x: x,
+    decimal.Decimal: _deserialize_decimal,
+}
+
+_DESERIALIZE_MAPPING_WITHFORMAT = {
+    "rfc3339": _deserialize_datetime,
+    "rfc7231": _deserialize_datetime_rfc7231,
+    "unix-timestamp": _deserialize_datetime_unix_timestamp,
+    "base64": _deserialize_bytes,
+    "base64url": _deserialize_bytes_base64,
+}
+
+
+def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None):
+    if rf and rf._format:
+        return _DESERIALIZE_MAPPING_WITHFORMAT.get(rf._format)
+    return _DESERIALIZE_MAPPING.get(annotation)
+
+
+def _get_type_alias_type(module_name: str, alias_name: str):
+    types = {
+        k: v
+        for k, v in sys.modules[module_name].__dict__.items()
+        if isinstance(v, typing._GenericAlias)  # type: ignore
+    }
+    if alias_name not in types:
+        return alias_name
+    return types[alias_name]
+
+
+def _get_model(module_name: str, model_name: str):
+    models = {k: v for k, v in sys.modules[module_name].__dict__.items() if isinstance(v, type)}
+    module_end = module_name.rsplit(".", 1)[0]
+    models.update({k: v for k, v in sys.modules[module_end].__dict__.items() if isinstance(v, type)})
+    if isinstance(model_name, str):
+        model_name = model_name.split(".")[-1]
+    if model_name not in models:
+        return model_name
+    return models[model_name]
+
+
+_UNSET = object()
+
+
+class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=unsubscriptable-object
+    def __init__(self, data: typing.Dict[str, typing.Any]) -> None:
+        self._data = copy.deepcopy(data)
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._data
+
+    def __getitem__(self, key: str) -> typing.Any:
+        return self._data.__getitem__(key)
+
+    def __setitem__(self, key: str, value: typing.Any) -> None:
+        self._data.__setitem__(key, value)
+
+    def __delitem__(self, key: str) -> None:
+        self._data.__delitem__(key)
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return self._data.__iter__()
+
+    def __len__(self) -> int:
+        return self._data.__len__()
+
+    def __ne__(self, other: typing.Any) -> bool:
+        return not self.__eq__(other)
+
+    def keys(self) -> typing.KeysView[str]:
+        return self._data.keys()
+
+    def values(self) -> typing.ValuesView[typing.Any]:
+        return self._data.values()
+
+    def items(self) -> typing.ItemsView[str, typing.Any]:
+        return self._data.items()
+
+    def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    @typing.overload
+    def pop(self, key: str) -> typing.Any:
+        ...
+
+    @typing.overload
+    def pop(self, key: str, default: _T) -> _T:
+        ...
+
+    @typing.overload
+    def pop(self, key: str, default: typing.Any) -> typing.Any:
+        ...
+
+    def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
+        if default is _UNSET:
+            return self._data.pop(key)
+        return self._data.pop(key, default)
+
+    def popitem(self) -> typing.Tuple[str, typing.Any]:
+        return self._data.popitem()
+
+    def clear(self) -> None:
+        self._data.clear()
+
+    def update(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        self._data.update(*args, **kwargs)
+
+    @typing.overload
+    def setdefault(self, key: str, default: None = None) -> None:
+        ...
+
+    @typing.overload
+    def setdefault(self, key: str, default: typing.Any) -> typing.Any:
+        ...
+
+    def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
+        if default is _UNSET:
+            return self._data.setdefault(key)
+        return self._data.setdefault(key, default)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        try:
+            other_model = self.__class__(other)
+        except Exception:
+            return False
+        return self._data == other_model._data
+
+    def __repr__(self) -> str:
+        return str(self._data)
+
+
+def _is_model(obj: typing.Any) -> bool:
+    return getattr(obj, "_is_model", False)
+
+
+def _serialize(o, format: typing.Optional[str] = None):  # pylint: disable=too-many-return-statements
+    if isinstance(o, list):
+        return [_serialize(x, format) for x in o]
+    if isinstance(o, dict):
+        return {k: _serialize(v, format) for k, v in o.items()}
+    if isinstance(o, set):
+        return {_serialize(x, format) for x in o}
+    if isinstance(o, tuple):
+        return tuple(_serialize(x, format) for x in o)
+    if isinstance(o, (bytes, bytearray)):
+        return _serialize_bytes(o, format)
+    if isinstance(o, decimal.Decimal):
+        return float(o)
+    if isinstance(o, enum.Enum):
+        return o.value
+    try:
+        # First try datetime.datetime
+        return _serialize_datetime(o, format)
+    except AttributeError:
+        pass
+    # Last, try datetime.timedelta
+    try:
+        return _timedelta_as_isostr(o)
+    except AttributeError:
+        # This will be raised when it hits value.total_seconds in the method above
+        pass
+    return o
+
+
+def _get_rest_field(
+    attr_to_rest_field: typing.Dict[str, "_RestField"], rest_name: str
+) -> typing.Optional["_RestField"]:
+    try:
+        return next(rf for rf in attr_to_rest_field.values() if rf._rest_name == rest_name)
+    except StopIteration:
+        return None
+
+
+def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typing.Any:
+    if not rf:
+        return _serialize(value, None)
+    if rf._is_multipart_file_input:
+        return value
+    if rf._is_model:
+        return _deserialize(rf._type, value)
+    return _serialize(value, rf._format)
+
+
+class Model(_MyMutableMapping):
+    _is_model = True
+
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        class_name = self.__class__.__name__
+        if len(args) > 1:
+            raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given")
+        dict_to_pass = {
+            rest_field._rest_name: rest_field._default
+            for rest_field in self._attr_to_rest_field.values()
+            if rest_field._default is not _UNSET
+        }
+        if args:
+            dict_to_pass.update(
+                {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()}
+            )
+        else:
+            non_attr_kwargs = [k for k in kwargs if k not in self._attr_to_rest_field]
+            if non_attr_kwargs:
+                # actual type errors only throw the first wrong keyword arg they see, so following that.
+                raise TypeError(f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'")
+            dict_to_pass.update(
+                {
+                    self._attr_to_rest_field[k]._rest_name: _create_value(self._attr_to_rest_field[k], v)
+                    for k, v in kwargs.items()
+                    if v is not None
+                }
+            )
+        super().__init__(dict_to_pass)
+
+    def copy(self) -> "Model":
+        return Model(self.__dict__)
+
+    def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self:  # pylint: disable=unused-argument
+        # we know the last three classes in mro are going to be 'Model', 'dict', and 'object'
+        mros = cls.__mro__[:-3][::-1]  # ignore model, dict, and object parents, and reverse the mro order
+        attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
+            k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
+        }
+        annotations = {
+            k: v
+            for mro_class in mros
+            if hasattr(mro_class, "__annotations__")  # pylint: disable=no-member
+            for k, v in mro_class.__annotations__.items()  # pylint: disable=no-member
+        }
+        for attr, rf in attr_to_rest_field.items():
+            rf._module = cls.__module__
+            if not rf._type:
+                rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None))
+            if not rf._rest_name_input:
+                rf._rest_name_input = attr
+        cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
+
+        return super().__new__(cls)  # pylint: disable=no-value-for-parameter
+
+    def __init_subclass__(cls, discriminator: typing.Optional[str] = None) -> None:
+        for base in cls.__bases__:
+            if hasattr(base, "__mapping__"):  # pylint: disable=no-member
+                base.__mapping__[discriminator or cls.__name__] = cls  # type: ignore  # pylint: disable=no-member
+
+    @classmethod
+    def _get_discriminator(cls, exist_discriminators) -> typing.Optional[str]:
+        for v in cls.__dict__.values():
+            if (
+                isinstance(v, _RestField) and v._is_discriminator and v._rest_name not in exist_discriminators
+            ):  # pylint: disable=protected-access
+                return v._rest_name  # pylint: disable=protected-access
+        return None
+
+    @classmethod
+    def _deserialize(cls, data, exist_discriminators):
+        if not hasattr(cls, "__mapping__"):  # pylint: disable=no-member
+            return cls(data)
+        discriminator = cls._get_discriminator(exist_discriminators)
+        exist_discriminators.append(discriminator)
+        mapped_cls = cls.__mapping__.get(data.get(discriminator), cls)  # pyright: ignore # pylint: disable=no-member
+        if mapped_cls == cls:
+            return cls(data)
+        return mapped_cls._deserialize(data, exist_discriminators)  # pylint: disable=protected-access
+
+    def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing.Any]:
+        """Return a dict that can be JSONify using json.dump.
+
+        :keyword bool exclude_readonly: Whether to remove the readonly properties.
+        :returns: A dict JSON compatible object
+        :rtype: dict
+        """
+
+        result = {}
+        if exclude_readonly:
+            readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)]
+        for k, v in self.items():
+            if exclude_readonly and k in readonly_props:  # pyright: ignore
+                continue
+            is_multipart_file_input = False
+            try:
+                is_multipart_file_input = next(
+                    rf for rf in self._attr_to_rest_field.values() if rf._rest_name == k
+                )._is_multipart_file_input
+            except StopIteration:
+                pass
+            result[k] = v if is_multipart_file_input else Model._as_dict_value(v, exclude_readonly=exclude_readonly)
+        return result
+
+    @staticmethod
+    def _as_dict_value(v: typing.Any, exclude_readonly: bool = False) -> typing.Any:
+        if v is None or isinstance(v, _Null):
+            return None
+        if isinstance(v, (list, tuple, set)):
+            return type(v)(Model._as_dict_value(x, exclude_readonly=exclude_readonly) for x in v)
+        if isinstance(v, dict):
+            return {dk: Model._as_dict_value(dv, exclude_readonly=exclude_readonly) for dk, dv in v.items()}
+        return v.as_dict(exclude_readonly=exclude_readonly) if hasattr(v, "as_dict") else v
+
+
+def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915, R0912
+    annotation: typing.Any,
+    module: typing.Optional[str],
+    rf: typing.Optional["_RestField"] = None,
+) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
+    if not annotation or annotation in [int, float]:
+        return None
+
+    # is it a type alias?
+    if isinstance(annotation, str):
+        if module is not None:
+            annotation = _get_type_alias_type(module, annotation)
+
+    # is it a forward ref / in quotes?
+    if isinstance(annotation, (str, typing.ForwardRef)):
+        try:
+            model_name = annotation.__forward_arg__  # type: ignore
+        except AttributeError:
+            model_name = annotation
+        if module is not None:
+            annotation = _get_model(module, model_name)
+
+    try:
+        if module and _is_model(annotation):
+            if rf:
+                rf._is_model = True
+
+            def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj):
+                if _is_model(obj):
+                    return obj
+                return _deserialize(model_deserializer, obj)
+
+            return functools.partial(_deserialize_model, annotation)  # pyright: ignore
+    except Exception:
+        pass
+
+    # is it a literal?
+    try:
+        if annotation.__origin__ is typing.Literal:  # pyright: ignore
+            return None
+    except AttributeError:
+        pass
+
+    # is it optional?
+    try:
+        if any(a for a in annotation.__args__ if a == type(None)):  # pyright: ignore
+            if_obj_deserializer = _get_deserialize_callable_from_annotation(
+                next(a for a in annotation.__args__ if a != type(None)), module, rf  # pyright: ignore
+            )
+
+            def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj):
+                if obj is None:
+                    return obj
+                return _deserialize_with_callable(if_obj_deserializer, obj)
+
+            return functools.partial(_deserialize_with_optional, if_obj_deserializer)
+    except AttributeError:
+        pass
+
+    if getattr(annotation, "__origin__", None) is typing.Union:
+        # initial ordering is we make `string` the last deserialization option, because it is often them most generic
+        deserializers = [
+            _get_deserialize_callable_from_annotation(arg, module, rf)
+            for arg in sorted(
+                annotation.__args__, key=lambda x: hasattr(x, "__name__") and x.__name__ == "str"  # pyright: ignore
+            )
+        ]
+
+        def _deserialize_with_union(deserializers, obj):
+            for deserializer in deserializers:
+                try:
+                    return _deserialize(deserializer, obj)
+                except DeserializationError:
+                    pass
+            raise DeserializationError()
+
+        return functools.partial(_deserialize_with_union, deserializers)
+
+    try:
+        if annotation._name == "Dict":  # pyright: ignore
+            value_deserializer = _get_deserialize_callable_from_annotation(
+                annotation.__args__[1], module, rf  # pyright: ignore
+            )
+
+            def _deserialize_dict(
+                value_deserializer: typing.Optional[typing.Callable],
+                obj: typing.Dict[typing.Any, typing.Any],
+            ):
+                if obj is None:
+                    return obj
+                return {k: _deserialize(value_deserializer, v, module) for k, v in obj.items()}
+
+            return functools.partial(
+                _deserialize_dict,
+                value_deserializer,
+            )
+    except (AttributeError, IndexError):
+        pass
+    try:
+        if annotation._name in ["List", "Set", "Tuple", "Sequence"]:  # pyright: ignore
+            if len(annotation.__args__) > 1:  # pyright: ignore
+
+                def _deserialize_multiple_sequence(
+                    entry_deserializers: typing.List[typing.Optional[typing.Callable]],
+                    obj,
+                ):
+                    if obj is None:
+                        return obj
+                    return type(obj)(
+                        _deserialize(deserializer, entry, module)
+                        for entry, deserializer in zip(obj, entry_deserializers)
+                    )
+
+                entry_deserializers = [
+                    _get_deserialize_callable_from_annotation(dt, module, rf)
+                    for dt in annotation.__args__  # pyright: ignore
+                ]
+                return functools.partial(_deserialize_multiple_sequence, entry_deserializers)
+            deserializer = _get_deserialize_callable_from_annotation(
+                annotation.__args__[0], module, rf  # pyright: ignore
+            )
+
+            def _deserialize_sequence(
+                deserializer: typing.Optional[typing.Callable],
+                obj,
+            ):
+                if obj is None:
+                    return obj
+                return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
+
+            return functools.partial(_deserialize_sequence, deserializer)
+    except (TypeError, IndexError, AttributeError, SyntaxError):
+        pass
+
+    def _deserialize_default(
+        deserializer,
+        obj,
+    ):
+        if obj is None:
+            return obj
+        try:
+            return _deserialize_with_callable(deserializer, obj)
+        except Exception:
+            pass
+        return obj
+
+    if get_deserializer(annotation, rf):
+        return functools.partial(_deserialize_default, get_deserializer(annotation, rf))
+
+    return functools.partial(_deserialize_default, annotation)
+
+
+def _deserialize_with_callable(
+    deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]],
+    value: typing.Any,
+):
+    try:
+        if value is None or isinstance(value, _Null):
+            return None
+        if deserializer is None:
+            return value
+        if isinstance(deserializer, CaseInsensitiveEnumMeta):
+            try:
+                return deserializer(value)
+            except ValueError:
+                # for unknown value, return raw value
+                return value
+        if isinstance(deserializer, type) and issubclass(deserializer, Model):
+            return deserializer._deserialize(value, [])
+        return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)(value)
+    except Exception as e:
+        raise DeserializationError() from e
+
+
+def _deserialize(
+    deserializer: typing.Any,
+    value: typing.Any,
+    module: typing.Optional[str] = None,
+    rf: typing.Optional["_RestField"] = None,
+    format: typing.Optional[str] = None,
+) -> typing.Any:
+    if isinstance(value, PipelineResponse):
+        value = value.http_response.json()
+    if rf is None and format:
+        rf = _RestField(format=format)
+    if not isinstance(deserializer, functools.partial):
+        deserializer = _get_deserialize_callable_from_annotation(deserializer, module, rf)
+    return _deserialize_with_callable(deserializer, value)
+
+
+class _RestField:
+    def __init__(
+        self,
+        *,
+        name: typing.Optional[str] = None,
+        type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
+        is_discriminator: bool = False,
+        visibility: typing.Optional[typing.List[str]] = None,
+        default: typing.Any = _UNSET,
+        format: typing.Optional[str] = None,
+        is_multipart_file_input: bool = False,
+    ):
+        self._type = type
+        self._rest_name_input = name
+        self._module: typing.Optional[str] = None
+        self._is_discriminator = is_discriminator
+        self._visibility = visibility
+        self._is_model = False
+        self._default = default
+        self._format = format
+        self._is_multipart_file_input = is_multipart_file_input
+
+    @property
+    def _class_type(self) -> typing.Any:
+        return getattr(self._type, "args", [None])[0]
+
+    @property
+    def _rest_name(self) -> str:
+        if self._rest_name_input is None:
+            raise ValueError("Rest name was never set")
+        return self._rest_name_input
+
+    def __get__(self, obj: Model, type=None):  # pylint: disable=redefined-builtin
+        # by this point, type and rest_name will have a value bc we default
+        # them in __new__ of the Model class
+        item = obj.get(self._rest_name)
+        if item is None:
+            return item
+        if self._is_model:
+            return item
+        return _deserialize(self._type, _serialize(item, self._format), rf=self)
+
+    def __set__(self, obj: Model, value) -> None:
+        if value is None:
+            # we want to wipe out entries if users set attr to None
+            try:
+                obj.__delitem__(self._rest_name)
+            except KeyError:
+                pass
+            return
+        if self._is_model:
+            if not _is_model(value):
+                value = _deserialize(self._type, value)
+            obj.__setitem__(self._rest_name, value)
+            return
+        obj.__setitem__(self._rest_name, _serialize(value, self._format))
+
+    def _get_deserialize_callable_from_annotation(
+        self, annotation: typing.Any
+    ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
+        return _get_deserialize_callable_from_annotation(annotation, self._module, self)
+
+
+def rest_field(
+    *,
+    name: typing.Optional[str] = None,
+    type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
+    visibility: typing.Optional[typing.List[str]] = None,
+    default: typing.Any = _UNSET,
+    format: typing.Optional[str] = None,
+    is_multipart_file_input: bool = False,
+) -> typing.Any:
+    return _RestField(
+        name=name,
+        type=type,
+        visibility=visibility,
+        default=default,
+        format=format,
+        is_multipart_file_input=is_multipart_file_input,
+    )
+
+
+def rest_discriminator(
+    *,
+    name: typing.Optional[str] = None,
+    type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
+) -> typing.Any:
+    return _RestField(name=name, type=type, is_discriminator=True)
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/__init__.py
new file mode 100644
index 0000000000000..24be3b0c64fce
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/__init__.py
@@ -0,0 +1,19 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._operations import RadiologyInsightsClientOperationsMixin
+
+from ._patch import __all__ as _patch_all
+from ._patch import *  # pylint: disable=unused-wildcard-import
+from ._patch import patch_sdk as _patch_sdk
+
+__all__ = [
+    "RadiologyInsightsClientOperationsMixin",
+]
+__all__.extend([p for p in _patch_all if p not in __all__])
+_patch_sdk()
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/_operations.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/_operations.py
new file mode 100644
index 0000000000000..083cdb935319e
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/_operations.py
@@ -0,0 +1,6693 @@
+# pylint: disable=too-many-lines,too-many-statements
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+from io import IOBase
+import json
+import sys
+from typing import Any, Callable, Dict, IO, List, Optional, TypeVar, Union, cast, overload
+
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceExistsError,
+    ResourceNotFoundError,
+    ResourceNotModifiedError,
+    map_error,
+)
+from azure.core.pipeline import PipelineResponse
+from azure.core.polling import LROPoller, NoPolling, PollingMethod
+from azure.core.polling.base_polling import LROBasePolling
+from azure.core.rest import HttpRequest, HttpResponse
+from azure.core.tracing.decorator import distributed_trace
+from azure.core.utils import case_insensitive_dict
+
+from .. import models as _models
+from .._model_base import SdkJSONEncoder, _deserialize
+from .._serialization import Serializer
+from .._vendor import RadiologyInsightsClientMixinABC
+
+if sys.version_info >= (3, 9):
+    from collections.abc import MutableMapping
+else:
+    from typing import MutableMapping  # type: ignore  # pylint: disable=ungrouped-imports
+JSON = MutableMapping[str, Any]  # pylint: disable=unsubscriptable-object
+T = TypeVar("T")
+ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
+
+_SERIALIZER = Serializer()
+_SERIALIZER.client_side_validation = False
+
+
+def build_radiology_insights_infer_radiology_insights_request(  # pylint: disable=name-too-long
+    id: str, *, expand: Optional[List[str]] = None, **kwargs: Any
+) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+    content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-01"))
+    accept = _headers.pop("Accept", "application/json")
+
+    # Construct URL
+    _url = "/radiology-insights/jobs/{id}"
+    path_format_arguments = {
+        "id": _SERIALIZER.url("id", id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct parameters
+    _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
+    if expand is not None:
+        _params["expand"] = [_SERIALIZER.query("expand", q, "str") if q is not None else "" for q in expand]
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+    if content_type is not None:
+        _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
+
+    return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
+
+
+class RadiologyInsightsClientOperationsMixin(RadiologyInsightsClientMixinABC):
+    def _infer_radiology_insights_initial(
+        self,
+        id: str,
+        resource: Union[_models.RadiologyInsightsJob, JSON, IO[bytes]],
+        *,
+        expand: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> JSON:
+        error_map = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        content_type = content_type or "application/json"
+        _content = None
+        if isinstance(resource, (IOBase, bytes)):
+            _content = resource
+        else:
+            _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
+
+        _request = build_radiology_insights_infer_radiology_insights_request(
+            id=id,
+            expand=expand,
+            content_type=content_type,
+            api_version=self._config.api_version,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        path_format_arguments = {
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
+        }
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200, 201]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)
+            error = _deserialize(_models.HealthInsightsErrorResponse, response.json())
+            raise HttpResponseError(response=response, model=error)
+
+        response_headers = {}
+        if response.status_code == 200:
+            response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
+            response_headers["Operation-Location"] = self._deserialize(
+                "str", response.headers.get("Operation-Location")
+            )
+
+            deserialized = _deserialize(JSON, response.json())
+
+        if response.status_code == 201:
+            response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
+            response_headers["Operation-Location"] = self._deserialize(
+                "str", response.headers.get("Operation-Location")
+            )
+
+            deserialized = _deserialize(JSON, response.json())
+
+        if cls:
+            return cls(pipeline_response, deserialized, response_headers)  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @overload
+    def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: _models.RadiologyInsightsJob,
+        *,
+        expand: Optional[List[str]] = None,
+        content_type: str = "application/json",
+        **kwargs: Any
+    ) -> LROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Required.
+        :type resource: ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: An instance of LROPoller that returns RadiologyInsightsJob. The RadiologyInsightsJob
+         is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.LROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                resource = {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+
+    @overload
+    def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: JSON,
+        *,
+        expand: Optional[List[str]] = None,
+        content_type: str = "application/json",
+        **kwargs: Any
+    ) -> LROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Required.
+        :type resource: JSON
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: An instance of LROPoller that returns RadiologyInsightsJob. The RadiologyInsightsJob
+         is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.LROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+
+    @overload
+    def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: IO[bytes],
+        *,
+        expand: Optional[List[str]] = None,
+        content_type: str = "application/json",
+        **kwargs: Any
+    ) -> LROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Required.
+        :type resource: IO[bytes]
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: An instance of LROPoller that returns RadiologyInsightsJob. The RadiologyInsightsJob
+         is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.LROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+
+    @distributed_trace
+    def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: Union[_models.RadiologyInsightsJob, JSON, IO[bytes]],
+        *,
+        expand: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> LROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Is one of the following types: RadiologyInsightsJob,
+         JSON, IO[bytes] Required.
+        :type resource: ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob or JSON or
+         IO[bytes]
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :return: An instance of LROPoller that returns RadiologyInsightsJob. The RadiologyInsightsJob
+         is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.LROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                resource = {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[_models.RadiologyInsightsJob] = kwargs.pop("cls", None)
+        polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
+        lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
+        cont_token: Optional[str] = kwargs.pop("continuation_token", None)
+        if cont_token is None:
+            raw_result = self._infer_radiology_insights_initial(
+                id=id,
+                resource=resource,
+                expand=expand,
+                content_type=content_type,
+                cls=lambda x, y, z: x,
+                headers=_headers,
+                params=_params,
+                **kwargs
+            )
+        kwargs.pop("error_map", None)
+
+        def get_long_running_output(pipeline_response):
+            response_headers = {}
+            response = pipeline_response.http_response
+            response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
+            response_headers["Operation-Location"] = self._deserialize(
+                "str", response.headers.get("Operation-Location")
+            )
+
+            deserialized = _deserialize(_models.RadiologyInsightsJob, response.json().get("result"))
+            if cls:
+                return cls(pipeline_response, deserialized, response_headers)  # type: ignore
+            return deserialized
+
+        path_format_arguments = {
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
+        }
+
+        if polling is True:
+            polling_method: PollingMethod = cast(
+                PollingMethod, LROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
+            )
+        elif polling is False:
+            polling_method = cast(PollingMethod, NoPolling())
+        else:
+            polling_method = polling
+        if cont_token:
+            return LROPoller[_models.RadiologyInsightsJob].from_continuation_token(
+                polling_method=polling_method,
+                continuation_token=cont_token,
+                client=self._client,
+                deserialization_callback=get_long_running_output,
+            )
+        return LROPoller[_models.RadiologyInsightsJob](
+            self._client, raw_result, get_long_running_output, polling_method  # type: ignore
+        )
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/_patch.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/_patch.py
new file mode 100644
index 0000000000000..f7dd32510333d
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_operations/_patch.py
@@ -0,0 +1,20 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Customize generated code here.
+
+Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
+"""
+from typing import List
+
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+
+
+def patch_sdk():
+    """Do not remove from this file.
+
+    `patch_sdk` is a last resort escape hatch that allows you to do customizations
+    you can't accomplish using the techniques described in
+    https://aka.ms/azsdk/python/dpcodegen/python/customize
+    """
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_patch.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_patch.py
new file mode 100644
index 0000000000000..f7dd32510333d
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_patch.py
@@ -0,0 +1,20 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Customize generated code here.
+
+Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
+"""
+from typing import List
+
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+
+
+def patch_sdk():
+    """Do not remove from this file.
+
+    `patch_sdk` is a last resort escape hatch that allows you to do customizations
+    you can't accomplish using the techniques described in
+    https://aka.ms/azsdk/python/dpcodegen/python/customize
+    """
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_serialization.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_serialization.py
new file mode 100644
index 0000000000000..2f781d740827a
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_serialization.py
@@ -0,0 +1,1998 @@
+# --------------------------------------------------------------------------
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+# pylint: skip-file
+# pyright: reportUnnecessaryTypeIgnoreComment=false
+
+from base64 import b64decode, b64encode
+import calendar
+import datetime
+import decimal
+import email
+from enum import Enum
+import json
+import logging
+import re
+import sys
+import codecs
+from typing import (
+    Dict,
+    Any,
+    cast,
+    Optional,
+    Union,
+    AnyStr,
+    IO,
+    Mapping,
+    Callable,
+    TypeVar,
+    MutableMapping,
+    Type,
+    List,
+    Mapping,
+)
+
+try:
+    from urllib import quote  # type: ignore
+except ImportError:
+    from urllib.parse import quote
+import xml.etree.ElementTree as ET
+
+import isodate  # type: ignore
+
+from azure.core.exceptions import DeserializationError, SerializationError
+from azure.core.serialization import NULL as CoreNull
+
+_BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
+
+ModelType = TypeVar("ModelType", bound="Model")
+JSON = MutableMapping[str, Any]
+
+
+class RawDeserializer:
+
+    # Accept "text" because we're open minded people...
+    JSON_REGEXP = re.compile(r"^(application|text)/([a-z+.]+\+)?json$")
+
+    # Name used in context
+    CONTEXT_NAME = "deserialized_data"
+
+    @classmethod
+    def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: Optional[str] = None) -> Any:
+        """Decode data according to content-type.
+
+        Accept a stream of data as well, but will be load at once in memory for now.
+
+        If no content-type, will return the string version (not bytes, not stream)
+
+        :param data: Input, could be bytes or stream (will be decoded with UTF8) or text
+        :type data: str or bytes or IO
+        :param str content_type: The content type.
+        """
+        if hasattr(data, "read"):
+            # Assume a stream
+            data = cast(IO, data).read()
+
+        if isinstance(data, bytes):
+            data_as_str = data.decode(encoding="utf-8-sig")
+        else:
+            # Explain to mypy the correct type.
+            data_as_str = cast(str, data)
+
+            # Remove Byte Order Mark if present in string
+            data_as_str = data_as_str.lstrip(_BOM)
+
+        if content_type is None:
+            return data
+
+        if cls.JSON_REGEXP.match(content_type):
+            try:
+                return json.loads(data_as_str)
+            except ValueError as err:
+                raise DeserializationError("JSON is invalid: {}".format(err), err)
+        elif "xml" in (content_type or []):
+            try:
+
+                try:
+                    if isinstance(data, unicode):  # type: ignore
+                        # If I'm Python 2.7 and unicode XML will scream if I try a "fromstring" on unicode string
+                        data_as_str = data_as_str.encode(encoding="utf-8")  # type: ignore
+                except NameError:
+                    pass
+
+                return ET.fromstring(data_as_str)  # nosec
+            except ET.ParseError as err:
+                # It might be because the server has an issue, and returned JSON with
+                # content-type XML....
+                # So let's try a JSON load, and if it's still broken
+                # let's flow the initial exception
+                def _json_attemp(data):
+                    try:
+                        return True, json.loads(data)
+                    except ValueError:
+                        return False, None  # Don't care about this one
+
+                success, json_result = _json_attemp(data)
+                if success:
+                    return json_result
+                # If i'm here, it's not JSON, it's not XML, let's scream
+                # and raise the last context in this block (the XML exception)
+                # The function hack is because Py2.7 messes up with exception
+                # context otherwise.
+                _LOGGER.critical("Wasn't XML not JSON, failing")
+                raise DeserializationError("XML is invalid") from err
+        raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
+
+    @classmethod
+    def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], headers: Mapping) -> Any:
+        """Deserialize from HTTP response.
+
+        Use bytes and headers to NOT use any requests/aiohttp or whatever
+        specific implementation.
+        Headers will tested for "content-type"
+        """
+        # Try to use content-type from headers if available
+        content_type = None
+        if "content-type" in headers:
+            content_type = headers["content-type"].split(";")[0].strip().lower()
+        # Ouch, this server did not declare what it sent...
+        # Let's guess it's JSON...
+        # Also, since Autorest was considering that an empty body was a valid JSON,
+        # need that test as well....
+        else:
+            content_type = "application/json"
+
+        if body_bytes:
+            return cls.deserialize_from_text(body_bytes, content_type)
+        return None
+
+
+_LOGGER = logging.getLogger(__name__)
+
+try:
+    _long_type = long  # type: ignore
+except NameError:
+    _long_type = int
+
+
+class UTC(datetime.tzinfo):
+    """Time Zone info for handling UTC"""
+
+    def utcoffset(self, dt):
+        """UTF offset for UTC is 0."""
+        return datetime.timedelta(0)
+
+    def tzname(self, dt):
+        """Timestamp representation."""
+        return "Z"
+
+    def dst(self, dt):
+        """No daylight saving for UTC."""
+        return datetime.timedelta(hours=1)
+
+
+try:
+    from datetime import timezone as _FixedOffset  # type: ignore
+except ImportError:  # Python 2.7
+
+    class _FixedOffset(datetime.tzinfo):  # type: ignore
+        """Fixed offset in minutes east from UTC.
+        Copy/pasted from Python doc
+        :param datetime.timedelta offset: offset in timedelta format
+        """
+
+        def __init__(self, offset):
+            self.__offset = offset
+
+        def utcoffset(self, dt):
+            return self.__offset
+
+        def tzname(self, dt):
+            return str(self.__offset.total_seconds() / 3600)
+
+        def __repr__(self):
+            return "<FixedOffset {}>".format(self.tzname(None))
+
+        def dst(self, dt):
+            return datetime.timedelta(0)
+
+        def __getinitargs__(self):
+            return (self.__offset,)
+
+
+try:
+    from datetime import timezone
+
+    TZ_UTC = timezone.utc
+except ImportError:
+    TZ_UTC = UTC()  # type: ignore
+
+_FLATTEN = re.compile(r"(?<!\\)\.")
+
+
+def attribute_transformer(key, attr_desc, value):
+    """A key transformer that returns the Python attribute.
+
+    :param str key: The attribute name
+    :param dict attr_desc: The attribute metadata
+    :param object value: The value
+    :returns: A key using attribute name
+    """
+    return (key, value)
+
+
+def full_restapi_key_transformer(key, attr_desc, value):
+    """A key transformer that returns the full RestAPI key path.
+
+    :param str _: The attribute name
+    :param dict attr_desc: The attribute metadata
+    :param object value: The value
+    :returns: A list of keys using RestAPI syntax.
+    """
+    keys = _FLATTEN.split(attr_desc["key"])
+    return ([_decode_attribute_map_key(k) for k in keys], value)
+
+
+def last_restapi_key_transformer(key, attr_desc, value):
+    """A key transformer that returns the last RestAPI key.
+
+    :param str key: The attribute name
+    :param dict attr_desc: The attribute metadata
+    :param object value: The value
+    :returns: The last RestAPI key.
+    """
+    key, value = full_restapi_key_transformer(key, attr_desc, value)
+    return (key[-1], value)
+
+
+def _create_xml_node(tag, prefix=None, ns=None):
+    """Create a XML node."""
+    if prefix and ns:
+        ET.register_namespace(prefix, ns)
+    if ns:
+        return ET.Element("{" + ns + "}" + tag)
+    else:
+        return ET.Element(tag)
+
+
+class Model(object):
+    """Mixin for all client request body/response body models to support
+    serialization and deserialization.
+    """
+
+    _subtype_map: Dict[str, Dict[str, Any]] = {}
+    _attribute_map: Dict[str, Dict[str, Any]] = {}
+    _validation: Dict[str, Dict[str, Any]] = {}
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.additional_properties: Optional[Dict[str, Any]] = {}
+        for k in kwargs:
+            if k not in self._attribute_map:
+                _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
+            elif k in self._validation and self._validation[k].get("readonly", False):
+                _LOGGER.warning("Readonly attribute %s will be ignored in class %s", k, self.__class__)
+            else:
+                setattr(self, k, kwargs[k])
+
+    def __eq__(self, other: Any) -> bool:
+        """Compare objects by comparing all attributes."""
+        if isinstance(other, self.__class__):
+            return self.__dict__ == other.__dict__
+        return False
+
+    def __ne__(self, other: Any) -> bool:
+        """Compare objects by comparing all attributes."""
+        return not self.__eq__(other)
+
+    def __str__(self) -> str:
+        return str(self.__dict__)
+
+    @classmethod
+    def enable_additional_properties_sending(cls) -> None:
+        cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"}
+
+    @classmethod
+    def is_xml_model(cls) -> bool:
+        try:
+            cls._xml_map  # type: ignore
+        except AttributeError:
+            return False
+        return True
+
+    @classmethod
+    def _create_xml_node(cls):
+        """Create XML node."""
+        try:
+            xml_map = cls._xml_map  # type: ignore
+        except AttributeError:
+            xml_map = {}
+
+        return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
+
+    def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
+        """Return the JSON that would be sent to server from this model.
+
+        This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
+
+        If you want XML serialization, you can pass the kwargs is_xml=True.
+
+        :param bool keep_readonly: If you want to serialize the readonly attributes
+        :returns: A dict JSON compatible object
+        :rtype: dict
+        """
+        serializer = Serializer(self._infer_class_models())
+        return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)  # type: ignore
+
+    def as_dict(
+        self,
+        keep_readonly: bool = True,
+        key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer,
+        **kwargs: Any
+    ) -> JSON:
+        """Return a dict that can be serialized using json.dump.
+
+        Advanced usage might optionally use a callback as parameter:
+
+        .. code::python
+
+            def my_key_transformer(key, attr_desc, value):
+                return key
+
+        Key is the attribute name used in Python. Attr_desc
+        is a dict of metadata. Currently contains 'type' with the
+        msrest type and 'key' with the RestAPI encoded key.
+        Value is the current value in this object.
+
+        The string returned will be used to serialize the key.
+        If the return type is a list, this is considered hierarchical
+        result dict.
+
+        See the three examples in this file:
+
+        - attribute_transformer
+        - full_restapi_key_transformer
+        - last_restapi_key_transformer
+
+        If you want XML serialization, you can pass the kwargs is_xml=True.
+
+        :param function key_transformer: A key transformer function.
+        :returns: A dict JSON compatible object
+        :rtype: dict
+        """
+        serializer = Serializer(self._infer_class_models())
+        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)  # type: ignore
+
+    @classmethod
+    def _infer_class_models(cls):
+        try:
+            str_models = cls.__module__.rsplit(".", 1)[0]
+            models = sys.modules[str_models]
+            client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
+            if cls.__name__ not in client_models:
+                raise ValueError("Not Autorest generated code")
+        except Exception:
+            # Assume it's not Autorest generated (tests?). Add ourselves as dependencies.
+            client_models = {cls.__name__: cls}
+        return client_models
+
+    @classmethod
+    def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
+        """Parse a str using the RestAPI syntax and return a model.
+
+        :param str data: A str using RestAPI structure. JSON by default.
+        :param str content_type: JSON by default, set application/xml if XML.
+        :returns: An instance of this model
+        :raises: DeserializationError if something went wrong
+        """
+        deserializer = Deserializer(cls._infer_class_models())
+        return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
+
+    @classmethod
+    def from_dict(
+        cls: Type[ModelType],
+        data: Any,
+        key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
+        content_type: Optional[str] = None,
+    ) -> ModelType:
+        """Parse a dict using given key extractor return a model.
+
+        By default consider key
+        extractors (rest_key_case_insensitive_extractor, attribute_key_case_insensitive_extractor
+        and last_rest_key_case_insensitive_extractor)
+
+        :param dict data: A dict using RestAPI structure
+        :param str content_type: JSON by default, set application/xml if XML.
+        :returns: An instance of this model
+        :raises: DeserializationError if something went wrong
+        """
+        deserializer = Deserializer(cls._infer_class_models())
+        deserializer.key_extractors = (  # type: ignore
+            [  # type: ignore
+                attribute_key_case_insensitive_extractor,
+                rest_key_case_insensitive_extractor,
+                last_rest_key_case_insensitive_extractor,
+            ]
+            if key_extractors is None
+            else key_extractors
+        )
+        return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
+
+    @classmethod
+    def _flatten_subtype(cls, key, objects):
+        if "_subtype_map" not in cls.__dict__:
+            return {}
+        result = dict(cls._subtype_map[key])
+        for valuetype in cls._subtype_map[key].values():
+            result.update(objects[valuetype]._flatten_subtype(key, objects))
+        return result
+
+    @classmethod
+    def _classify(cls, response, objects):
+        """Check the class _subtype_map for any child classes.
+        We want to ignore any inherited _subtype_maps.
+        Remove the polymorphic key from the initial data.
+        """
+        for subtype_key in cls.__dict__.get("_subtype_map", {}).keys():
+            subtype_value = None
+
+            if not isinstance(response, ET.Element):
+                rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
+                subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None)
+            else:
+                subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response)
+            if subtype_value:
+                # Try to match base class. Can be class name only
+                # (bug to fix in Autorest to support x-ms-discriminator-name)
+                if cls.__name__ == subtype_value:
+                    return cls
+                flatten_mapping_type = cls._flatten_subtype(subtype_key, objects)
+                try:
+                    return objects[flatten_mapping_type[subtype_value]]  # type: ignore
+                except KeyError:
+                    _LOGGER.warning(
+                        "Subtype value %s has no mapping, use base class %s.",
+                        subtype_value,
+                        cls.__name__,
+                    )
+                    break
+            else:
+                _LOGGER.warning("Discriminator %s is absent or null, use base class %s.", subtype_key, cls.__name__)
+                break
+        return cls
+
+    @classmethod
+    def _get_rest_key_parts(cls, attr_key):
+        """Get the RestAPI key of this attr, split it and decode part
+        :param str attr_key: Attribute key must be in attribute_map.
+        :returns: A list of RestAPI part
+        :rtype: list
+        """
+        rest_split_key = _FLATTEN.split(cls._attribute_map[attr_key]["key"])
+        return [_decode_attribute_map_key(key_part) for key_part in rest_split_key]
+
+
+def _decode_attribute_map_key(key):
+    """This decode a key in an _attribute_map to the actual key we want to look at
+    inside the received data.
+
+    :param str key: A key string from the generated code
+    """
+    return key.replace("\\.", ".")
+
+
+class Serializer(object):
+    """Request object model serializer."""
+
+    basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
+
+    _xml_basic_types_serializers = {"bool": lambda x: str(x).lower()}
+    days = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri", 5: "Sat", 6: "Sun"}
+    months = {
+        1: "Jan",
+        2: "Feb",
+        3: "Mar",
+        4: "Apr",
+        5: "May",
+        6: "Jun",
+        7: "Jul",
+        8: "Aug",
+        9: "Sep",
+        10: "Oct",
+        11: "Nov",
+        12: "Dec",
+    }
+    validation = {
+        "min_length": lambda x, y: len(x) < y,
+        "max_length": lambda x, y: len(x) > y,
+        "minimum": lambda x, y: x < y,
+        "maximum": lambda x, y: x > y,
+        "minimum_ex": lambda x, y: x <= y,
+        "maximum_ex": lambda x, y: x >= y,
+        "min_items": lambda x, y: len(x) < y,
+        "max_items": lambda x, y: len(x) > y,
+        "pattern": lambda x, y: not re.match(y, x, re.UNICODE),
+        "unique": lambda x, y: len(x) != len(set(x)),
+        "multiple": lambda x, y: x % y != 0,
+    }
+
+    def __init__(self, classes: Optional[Mapping[str, type]] = None):
+        self.serialize_type = {
+            "iso-8601": Serializer.serialize_iso,
+            "rfc-1123": Serializer.serialize_rfc,
+            "unix-time": Serializer.serialize_unix,
+            "duration": Serializer.serialize_duration,
+            "date": Serializer.serialize_date,
+            "time": Serializer.serialize_time,
+            "decimal": Serializer.serialize_decimal,
+            "long": Serializer.serialize_long,
+            "bytearray": Serializer.serialize_bytearray,
+            "base64": Serializer.serialize_base64,
+            "object": self.serialize_object,
+            "[]": self.serialize_iter,
+            "{}": self.serialize_dict,
+        }
+        self.dependencies: Dict[str, type] = dict(classes) if classes else {}
+        self.key_transformer = full_restapi_key_transformer
+        self.client_side_validation = True
+
+    def _serialize(self, target_obj, data_type=None, **kwargs):
+        """Serialize data into a string according to type.
+
+        :param target_obj: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str, dict
+        :raises: SerializationError if serialization fails.
+        """
+        key_transformer = kwargs.get("key_transformer", self.key_transformer)
+        keep_readonly = kwargs.get("keep_readonly", False)
+        if target_obj is None:
+            return None
+
+        attr_name = None
+        class_name = target_obj.__class__.__name__
+
+        if data_type:
+            return self.serialize_data(target_obj, data_type, **kwargs)
+
+        if not hasattr(target_obj, "_attribute_map"):
+            data_type = type(target_obj).__name__
+            if data_type in self.basic_types.values():
+                return self.serialize_data(target_obj, data_type, **kwargs)
+
+        # Force "is_xml" kwargs if we detect a XML model
+        try:
+            is_xml_model_serialization = kwargs["is_xml"]
+        except KeyError:
+            is_xml_model_serialization = kwargs.setdefault("is_xml", target_obj.is_xml_model())
+
+        serialized = {}
+        if is_xml_model_serialization:
+            serialized = target_obj._create_xml_node()
+        try:
+            attributes = target_obj._attribute_map
+            for attr, attr_desc in attributes.items():
+                attr_name = attr
+                if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False):
+                    continue
+
+                if attr_name == "additional_properties" and attr_desc["key"] == "":
+                    if target_obj.additional_properties is not None:
+                        serialized.update(target_obj.additional_properties)
+                    continue
+                try:
+
+                    orig_attr = getattr(target_obj, attr)
+                    if is_xml_model_serialization:
+                        pass  # Don't provide "transformer" for XML for now. Keep "orig_attr"
+                    else:  # JSON
+                        keys, orig_attr = key_transformer(attr, attr_desc.copy(), orig_attr)
+                        keys = keys if isinstance(keys, list) else [keys]
+
+                    kwargs["serialization_ctxt"] = attr_desc
+                    new_attr = self.serialize_data(orig_attr, attr_desc["type"], **kwargs)
+
+                    if is_xml_model_serialization:
+                        xml_desc = attr_desc.get("xml", {})
+                        xml_name = xml_desc.get("name", attr_desc["key"])
+                        xml_prefix = xml_desc.get("prefix", None)
+                        xml_ns = xml_desc.get("ns", None)
+                        if xml_desc.get("attr", False):
+                            if xml_ns:
+                                ET.register_namespace(xml_prefix, xml_ns)
+                                xml_name = "{{{}}}{}".format(xml_ns, xml_name)
+                            serialized.set(xml_name, new_attr)  # type: ignore
+                            continue
+                        if xml_desc.get("text", False):
+                            serialized.text = new_attr  # type: ignore
+                            continue
+                        if isinstance(new_attr, list):
+                            serialized.extend(new_attr)  # type: ignore
+                        elif isinstance(new_attr, ET.Element):
+                            # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces.
+                            if "name" not in getattr(orig_attr, "_xml_map", {}):
+                                splitted_tag = new_attr.tag.split("}")
+                                if len(splitted_tag) == 2:  # Namespace
+                                    new_attr.tag = "}".join([splitted_tag[0], xml_name])
+                                else:
+                                    new_attr.tag = xml_name
+                            serialized.append(new_attr)  # type: ignore
+                        else:  # That's a basic type
+                            # Integrate namespace if necessary
+                            local_node = _create_xml_node(xml_name, xml_prefix, xml_ns)
+                            local_node.text = str(new_attr)
+                            serialized.append(local_node)  # type: ignore
+                    else:  # JSON
+                        for k in reversed(keys):  # type: ignore
+                            new_attr = {k: new_attr}
+
+                        _new_attr = new_attr
+                        _serialized = serialized
+                        for k in keys:  # type: ignore
+                            if k not in _serialized:
+                                _serialized.update(_new_attr)  # type: ignore
+                            _new_attr = _new_attr[k]  # type: ignore
+                            _serialized = _serialized[k]
+                except ValueError as err:
+                    if isinstance(err, SerializationError):
+                        raise
+
+        except (AttributeError, KeyError, TypeError) as err:
+            msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj))
+            raise SerializationError(msg) from err
+        else:
+            return serialized
+
+    def body(self, data, data_type, **kwargs):
+        """Serialize data intended for a request body.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: dict
+        :raises: SerializationError if serialization fails.
+        :raises: ValueError if data is None
+        """
+
+        # Just in case this is a dict
+        internal_data_type_str = data_type.strip("[]{}")
+        internal_data_type = self.dependencies.get(internal_data_type_str, None)
+        try:
+            is_xml_model_serialization = kwargs["is_xml"]
+        except KeyError:
+            if internal_data_type and issubclass(internal_data_type, Model):
+                is_xml_model_serialization = kwargs.setdefault("is_xml", internal_data_type.is_xml_model())
+            else:
+                is_xml_model_serialization = False
+        if internal_data_type and not isinstance(internal_data_type, Enum):
+            try:
+                deserializer = Deserializer(self.dependencies)
+                # Since it's on serialization, it's almost sure that format is not JSON REST
+                # We're not able to deal with additional properties for now.
+                deserializer.additional_properties_detection = False
+                if is_xml_model_serialization:
+                    deserializer.key_extractors = [  # type: ignore
+                        attribute_key_case_insensitive_extractor,
+                    ]
+                else:
+                    deserializer.key_extractors = [
+                        rest_key_case_insensitive_extractor,
+                        attribute_key_case_insensitive_extractor,
+                        last_rest_key_case_insensitive_extractor,
+                    ]
+                data = deserializer._deserialize(data_type, data)
+            except DeserializationError as err:
+                raise SerializationError("Unable to build a model: " + str(err)) from err
+
+        return self._serialize(data, data_type, **kwargs)
+
+    def url(self, name, data, data_type, **kwargs):
+        """Serialize data intended for a URL path.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str
+        :raises: TypeError if serialization fails.
+        :raises: ValueError if data is None
+        """
+        try:
+            output = self.serialize_data(data, data_type, **kwargs)
+            if data_type == "bool":
+                output = json.dumps(output)
+
+            if kwargs.get("skip_quote") is True:
+                output = str(output)
+                output = output.replace("{", quote("{")).replace("}", quote("}"))
+            else:
+                output = quote(str(output), safe="")
+        except SerializationError:
+            raise TypeError("{} must be type {}.".format(name, data_type))
+        else:
+            return output
+
+    def query(self, name, data, data_type, **kwargs):
+        """Serialize data intended for a URL query.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :keyword bool skip_quote: Whether to skip quote the serialized result.
+        Defaults to False.
+        :rtype: str, list
+        :raises: TypeError if serialization fails.
+        :raises: ValueError if data is None
+        """
+        try:
+            # Treat the list aside, since we don't want to encode the div separator
+            if data_type.startswith("["):
+                internal_data_type = data_type[1:-1]
+                do_quote = not kwargs.get("skip_quote", False)
+                return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs)
+
+            # Not a list, regular serialization
+            output = self.serialize_data(data, data_type, **kwargs)
+            if data_type == "bool":
+                output = json.dumps(output)
+            if kwargs.get("skip_quote") is True:
+                output = str(output)
+            else:
+                output = quote(str(output), safe="")
+        except SerializationError:
+            raise TypeError("{} must be type {}.".format(name, data_type))
+        else:
+            return str(output)
+
+    def header(self, name, data, data_type, **kwargs):
+        """Serialize data intended for a request header.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str
+        :raises: TypeError if serialization fails.
+        :raises: ValueError if data is None
+        """
+        try:
+            if data_type in ["[str]"]:
+                data = ["" if d is None else d for d in data]
+
+            output = self.serialize_data(data, data_type, **kwargs)
+            if data_type == "bool":
+                output = json.dumps(output)
+        except SerializationError:
+            raise TypeError("{} must be type {}.".format(name, data_type))
+        else:
+            return str(output)
+
+    def serialize_data(self, data, data_type, **kwargs):
+        """Serialize generic data according to supplied data type.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :param bool required: Whether it's essential that the data not be
+         empty or None
+        :raises: AttributeError if required data is None.
+        :raises: ValueError if data is None
+        :raises: SerializationError if serialization fails.
+        """
+        if data is None:
+            raise ValueError("No value for given attribute")
+
+        try:
+            if data is CoreNull:
+                return None
+            if data_type in self.basic_types.values():
+                return self.serialize_basic(data, data_type, **kwargs)
+
+            elif data_type in self.serialize_type:
+                return self.serialize_type[data_type](data, **kwargs)
+
+            # If dependencies is empty, try with current data class
+            # It has to be a subclass of Enum anyway
+            enum_type = self.dependencies.get(data_type, data.__class__)
+            if issubclass(enum_type, Enum):
+                return Serializer.serialize_enum(data, enum_obj=enum_type)
+
+            iter_type = data_type[0] + data_type[-1]
+            if iter_type in self.serialize_type:
+                return self.serialize_type[iter_type](data, data_type[1:-1], **kwargs)
+
+        except (ValueError, TypeError) as err:
+            msg = "Unable to serialize value: {!r} as type: {!r}."
+            raise SerializationError(msg.format(data, data_type)) from err
+        else:
+            return self._serialize(data, **kwargs)
+
+    @classmethod
+    def _get_custom_serializers(cls, data_type, **kwargs):
+        custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type)
+        if custom_serializer:
+            return custom_serializer
+        if kwargs.get("is_xml", False):
+            return cls._xml_basic_types_serializers.get(data_type)
+
+    @classmethod
+    def serialize_basic(cls, data, data_type, **kwargs):
+        """Serialize basic builting data type.
+        Serializes objects to str, int, float or bool.
+
+        Possible kwargs:
+        - basic_types_serializers dict[str, callable] : If set, use the callable as serializer
+        - is_xml bool : If set, use xml_basic_types_serializers
+
+        :param data: Object to be serialized.
+        :param str data_type: Type of object in the iterable.
+        """
+        custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
+        if custom_serializer:
+            return custom_serializer(data)
+        if data_type == "str":
+            return cls.serialize_unicode(data)
+        return eval(data_type)(data)  # nosec
+
+    @classmethod
+    def serialize_unicode(cls, data):
+        """Special handling for serializing unicode strings in Py2.
+        Encode to UTF-8 if unicode, otherwise handle as a str.
+
+        :param data: Object to be serialized.
+        :rtype: str
+        """
+        try:  # If I received an enum, return its value
+            return data.value
+        except AttributeError:
+            pass
+
+        try:
+            if isinstance(data, unicode):  # type: ignore
+                # Don't change it, JSON and XML ElementTree are totally able
+                # to serialize correctly u'' strings
+                return data
+        except NameError:
+            return str(data)
+        else:
+            return str(data)
+
+    def serialize_iter(self, data, iter_type, div=None, **kwargs):
+        """Serialize iterable.
+
+        Supported kwargs:
+        - serialization_ctxt dict : The current entry of _attribute_map, or same format.
+          serialization_ctxt['type'] should be same as data_type.
+        - is_xml bool : If set, serialize as XML
+
+        :param list attr: Object to be serialized.
+        :param str iter_type: Type of object in the iterable.
+        :param bool required: Whether the objects in the iterable must
+         not be None or empty.
+        :param str div: If set, this str will be used to combine the elements
+         in the iterable into a combined string. Default is 'None'.
+        :keyword bool do_quote: Whether to quote the serialized result of each iterable element.
+        Defaults to False.
+        :rtype: list, str
+        """
+        if isinstance(data, str):
+            raise SerializationError("Refuse str type as a valid iter type.")
+
+        serialization_ctxt = kwargs.get("serialization_ctxt", {})
+        is_xml = kwargs.get("is_xml", False)
+
+        serialized = []
+        for d in data:
+            try:
+                serialized.append(self.serialize_data(d, iter_type, **kwargs))
+            except ValueError as err:
+                if isinstance(err, SerializationError):
+                    raise
+                serialized.append(None)
+
+        if kwargs.get("do_quote", False):
+            serialized = ["" if s is None else quote(str(s), safe="") for s in serialized]
+
+        if div:
+            serialized = ["" if s is None else str(s) for s in serialized]
+            serialized = div.join(serialized)
+
+        if "xml" in serialization_ctxt or is_xml:
+            # XML serialization is more complicated
+            xml_desc = serialization_ctxt.get("xml", {})
+            xml_name = xml_desc.get("name")
+            if not xml_name:
+                xml_name = serialization_ctxt["key"]
+
+            # Create a wrap node if necessary (use the fact that Element and list have "append")
+            is_wrapped = xml_desc.get("wrapped", False)
+            node_name = xml_desc.get("itemsName", xml_name)
+            if is_wrapped:
+                final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
+            else:
+                final_result = []
+            # All list elements to "local_node"
+            for el in serialized:
+                if isinstance(el, ET.Element):
+                    el_node = el
+                else:
+                    el_node = _create_xml_node(node_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
+                    if el is not None:  # Otherwise it writes "None" :-p
+                        el_node.text = str(el)
+                final_result.append(el_node)
+            return final_result
+        return serialized
+
+    def serialize_dict(self, attr, dict_type, **kwargs):
+        """Serialize a dictionary of objects.
+
+        :param dict attr: Object to be serialized.
+        :param str dict_type: Type of object in the dictionary.
+        :param bool required: Whether the objects in the dictionary must
+         not be None or empty.
+        :rtype: dict
+        """
+        serialization_ctxt = kwargs.get("serialization_ctxt", {})
+        serialized = {}
+        for key, value in attr.items():
+            try:
+                serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs)
+            except ValueError as err:
+                if isinstance(err, SerializationError):
+                    raise
+                serialized[self.serialize_unicode(key)] = None
+
+        if "xml" in serialization_ctxt:
+            # XML serialization is more complicated
+            xml_desc = serialization_ctxt["xml"]
+            xml_name = xml_desc["name"]
+
+            final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
+            for key, value in serialized.items():
+                ET.SubElement(final_result, key).text = value
+            return final_result
+
+        return serialized
+
+    def serialize_object(self, attr, **kwargs):
+        """Serialize a generic object.
+        This will be handled as a dictionary. If object passed in is not
+        a basic type (str, int, float, dict, list) it will simply be
+        cast to str.
+
+        :param dict attr: Object to be serialized.
+        :rtype: dict or str
+        """
+        if attr is None:
+            return None
+        if isinstance(attr, ET.Element):
+            return attr
+        obj_type = type(attr)
+        if obj_type in self.basic_types:
+            return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs)
+        if obj_type is _long_type:
+            return self.serialize_long(attr)
+        if obj_type is str:
+            return self.serialize_unicode(attr)
+        if obj_type is datetime.datetime:
+            return self.serialize_iso(attr)
+        if obj_type is datetime.date:
+            return self.serialize_date(attr)
+        if obj_type is datetime.time:
+            return self.serialize_time(attr)
+        if obj_type is datetime.timedelta:
+            return self.serialize_duration(attr)
+        if obj_type is decimal.Decimal:
+            return self.serialize_decimal(attr)
+
+        # If it's a model or I know this dependency, serialize as a Model
+        elif obj_type in self.dependencies.values() or isinstance(attr, Model):
+            return self._serialize(attr)
+
+        if obj_type == dict:
+            serialized = {}
+            for key, value in attr.items():
+                try:
+                    serialized[self.serialize_unicode(key)] = self.serialize_object(value, **kwargs)
+                except ValueError:
+                    serialized[self.serialize_unicode(key)] = None
+            return serialized
+
+        if obj_type == list:
+            serialized = []
+            for obj in attr:
+                try:
+                    serialized.append(self.serialize_object(obj, **kwargs))
+                except ValueError:
+                    pass
+            return serialized
+        return str(attr)
+
+    @staticmethod
+    def serialize_enum(attr, enum_obj=None):
+        try:
+            result = attr.value
+        except AttributeError:
+            result = attr
+        try:
+            enum_obj(result)  # type: ignore
+            return result
+        except ValueError:
+            for enum_value in enum_obj:  # type: ignore
+                if enum_value.value.lower() == str(attr).lower():
+                    return enum_value.value
+            error = "{!r} is not valid value for enum {!r}"
+            raise SerializationError(error.format(attr, enum_obj))
+
+    @staticmethod
+    def serialize_bytearray(attr, **kwargs):
+        """Serialize bytearray into base-64 string.
+
+        :param attr: Object to be serialized.
+        :rtype: str
+        """
+        return b64encode(attr).decode()
+
+    @staticmethod
+    def serialize_base64(attr, **kwargs):
+        """Serialize str into base-64 string.
+
+        :param attr: Object to be serialized.
+        :rtype: str
+        """
+        encoded = b64encode(attr).decode("ascii")
+        return encoded.strip("=").replace("+", "-").replace("/", "_")
+
+    @staticmethod
+    def serialize_decimal(attr, **kwargs):
+        """Serialize Decimal object to float.
+
+        :param attr: Object to be serialized.
+        :rtype: float
+        """
+        return float(attr)
+
+    @staticmethod
+    def serialize_long(attr, **kwargs):
+        """Serialize long (Py2) or int (Py3).
+
+        :param attr: Object to be serialized.
+        :rtype: int/long
+        """
+        return _long_type(attr)
+
+    @staticmethod
+    def serialize_date(attr, **kwargs):
+        """Serialize Date object into ISO-8601 formatted string.
+
+        :param Date attr: Object to be serialized.
+        :rtype: str
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_date(attr)
+        t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day)
+        return t
+
+    @staticmethod
+    def serialize_time(attr, **kwargs):
+        """Serialize Time object into ISO-8601 formatted string.
+
+        :param datetime.time attr: Object to be serialized.
+        :rtype: str
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_time(attr)
+        t = "{:02}:{:02}:{:02}".format(attr.hour, attr.minute, attr.second)
+        if attr.microsecond:
+            t += ".{:02}".format(attr.microsecond)
+        return t
+
+    @staticmethod
+    def serialize_duration(attr, **kwargs):
+        """Serialize TimeDelta object into ISO-8601 formatted string.
+
+        :param TimeDelta attr: Object to be serialized.
+        :rtype: str
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_duration(attr)
+        return isodate.duration_isoformat(attr)
+
+    @staticmethod
+    def serialize_rfc(attr, **kwargs):
+        """Serialize Datetime object into RFC-1123 formatted string.
+
+        :param Datetime attr: Object to be serialized.
+        :rtype: str
+        :raises: TypeError if format invalid.
+        """
+        try:
+            if not attr.tzinfo:
+                _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
+            utc = attr.utctimetuple()
+        except AttributeError:
+            raise TypeError("RFC1123 object must be valid Datetime object.")
+
+        return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format(
+            Serializer.days[utc.tm_wday],
+            utc.tm_mday,
+            Serializer.months[utc.tm_mon],
+            utc.tm_year,
+            utc.tm_hour,
+            utc.tm_min,
+            utc.tm_sec,
+        )
+
+    @staticmethod
+    def serialize_iso(attr, **kwargs):
+        """Serialize Datetime object into ISO-8601 formatted string.
+
+        :param Datetime attr: Object to be serialized.
+        :rtype: str
+        :raises: SerializationError if format invalid.
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_datetime(attr)
+        try:
+            if not attr.tzinfo:
+                _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
+            utc = attr.utctimetuple()
+            if utc.tm_year > 9999 or utc.tm_year < 1:
+                raise OverflowError("Hit max or min date")
+
+            microseconds = str(attr.microsecond).rjust(6, "0").rstrip("0").ljust(3, "0")
+            if microseconds:
+                microseconds = "." + microseconds
+            date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format(
+                utc.tm_year, utc.tm_mon, utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec
+            )
+            return date + microseconds + "Z"
+        except (ValueError, OverflowError) as err:
+            msg = "Unable to serialize datetime object."
+            raise SerializationError(msg) from err
+        except AttributeError as err:
+            msg = "ISO-8601 object must be valid Datetime object."
+            raise TypeError(msg) from err
+
+    @staticmethod
+    def serialize_unix(attr, **kwargs):
+        """Serialize Datetime object into IntTime format.
+        This is represented as seconds.
+
+        :param Datetime attr: Object to be serialized.
+        :rtype: int
+        :raises: SerializationError if format invalid
+        """
+        if isinstance(attr, int):
+            return attr
+        try:
+            if not attr.tzinfo:
+                _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
+            return int(calendar.timegm(attr.utctimetuple()))
+        except AttributeError:
+            raise TypeError("Unix time object must be valid Datetime object.")
+
+
+def rest_key_extractor(attr, attr_desc, data):
+    key = attr_desc["key"]
+    working_data = data
+
+    while "." in key:
+        # Need the cast, as for some reasons "split" is typed as list[str | Any]
+        dict_keys = cast(List[str], _FLATTEN.split(key))
+        if len(dict_keys) == 1:
+            key = _decode_attribute_map_key(dict_keys[0])
+            break
+        working_key = _decode_attribute_map_key(dict_keys[0])
+        working_data = working_data.get(working_key, data)
+        if working_data is None:
+            # If at any point while following flatten JSON path see None, it means
+            # that all properties under are None as well
+            return None
+        key = ".".join(dict_keys[1:])
+
+    return working_data.get(key)
+
+
+def rest_key_case_insensitive_extractor(attr, attr_desc, data):
+    key = attr_desc["key"]
+    working_data = data
+
+    while "." in key:
+        dict_keys = _FLATTEN.split(key)
+        if len(dict_keys) == 1:
+            key = _decode_attribute_map_key(dict_keys[0])
+            break
+        working_key = _decode_attribute_map_key(dict_keys[0])
+        working_data = attribute_key_case_insensitive_extractor(working_key, None, working_data)
+        if working_data is None:
+            # If at any point while following flatten JSON path see None, it means
+            # that all properties under are None as well
+            return None
+        key = ".".join(dict_keys[1:])
+
+    if working_data:
+        return attribute_key_case_insensitive_extractor(key, None, working_data)
+
+
+def last_rest_key_extractor(attr, attr_desc, data):
+    """Extract the attribute in "data" based on the last part of the JSON path key."""
+    key = attr_desc["key"]
+    dict_keys = _FLATTEN.split(key)
+    return attribute_key_extractor(dict_keys[-1], None, data)
+
+
+def last_rest_key_case_insensitive_extractor(attr, attr_desc, data):
+    """Extract the attribute in "data" based on the last part of the JSON path key.
+
+    This is the case insensitive version of "last_rest_key_extractor"
+    """
+    key = attr_desc["key"]
+    dict_keys = _FLATTEN.split(key)
+    return attribute_key_case_insensitive_extractor(dict_keys[-1], None, data)
+
+
+def attribute_key_extractor(attr, _, data):
+    return data.get(attr)
+
+
+def attribute_key_case_insensitive_extractor(attr, _, data):
+    found_key = None
+    lower_attr = attr.lower()
+    for key in data:
+        if lower_attr == key.lower():
+            found_key = key
+            break
+
+    return data.get(found_key)
+
+
+def _extract_name_from_internal_type(internal_type):
+    """Given an internal type XML description, extract correct XML name with namespace.
+
+    :param dict internal_type: An model type
+    :rtype: tuple
+    :returns: A tuple XML name + namespace dict
+    """
+    internal_type_xml_map = getattr(internal_type, "_xml_map", {})
+    xml_name = internal_type_xml_map.get("name", internal_type.__name__)
+    xml_ns = internal_type_xml_map.get("ns", None)
+    if xml_ns:
+        xml_name = "{{{}}}{}".format(xml_ns, xml_name)
+    return xml_name
+
+
+def xml_key_extractor(attr, attr_desc, data):
+    if isinstance(data, dict):
+        return None
+
+    # Test if this model is XML ready first
+    if not isinstance(data, ET.Element):
+        return None
+
+    xml_desc = attr_desc.get("xml", {})
+    xml_name = xml_desc.get("name", attr_desc["key"])
+
+    # Look for a children
+    is_iter_type = attr_desc["type"].startswith("[")
+    is_wrapped = xml_desc.get("wrapped", False)
+    internal_type = attr_desc.get("internalType", None)
+    internal_type_xml_map = getattr(internal_type, "_xml_map", {})
+
+    # Integrate namespace if necessary
+    xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None))
+    if xml_ns:
+        xml_name = "{{{}}}{}".format(xml_ns, xml_name)
+
+    # If it's an attribute, that's simple
+    if xml_desc.get("attr", False):
+        return data.get(xml_name)
+
+    # If it's x-ms-text, that's simple too
+    if xml_desc.get("text", False):
+        return data.text
+
+    # Scenario where I take the local name:
+    # - Wrapped node
+    # - Internal type is an enum (considered basic types)
+    # - Internal type has no XML/Name node
+    if is_wrapped or (internal_type and (issubclass(internal_type, Enum) or "name" not in internal_type_xml_map)):
+        children = data.findall(xml_name)
+    # If internal type has a local name and it's not a list, I use that name
+    elif not is_iter_type and internal_type and "name" in internal_type_xml_map:
+        xml_name = _extract_name_from_internal_type(internal_type)
+        children = data.findall(xml_name)
+    # That's an array
+    else:
+        if internal_type:  # Complex type, ignore itemsName and use the complex type name
+            items_name = _extract_name_from_internal_type(internal_type)
+        else:
+            items_name = xml_desc.get("itemsName", xml_name)
+        children = data.findall(items_name)
+
+    if len(children) == 0:
+        if is_iter_type:
+            if is_wrapped:
+                return None  # is_wrapped no node, we want None
+            else:
+                return []  # not wrapped, assume empty list
+        return None  # Assume it's not there, maybe an optional node.
+
+    # If is_iter_type and not wrapped, return all found children
+    if is_iter_type:
+        if not is_wrapped:
+            return children
+        else:  # Iter and wrapped, should have found one node only (the wrap one)
+            if len(children) != 1:
+                raise DeserializationError(
+                    "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format(
+                        xml_name
+                    )
+                )
+            return list(children[0])  # Might be empty list and that's ok.
+
+    # Here it's not a itertype, we should have found one element only or empty
+    if len(children) > 1:
+        raise DeserializationError("Find several XML '{}' where it was not expected".format(xml_name))
+    return children[0]
+
+
+class Deserializer(object):
+    """Response object model deserializer.
+
+    :param dict classes: Class type dictionary for deserializing complex types.
+    :ivar list key_extractors: Ordered list of extractors to be used by this deserializer.
+    """
+
+    basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
+
+    valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
+
+    def __init__(self, classes: Optional[Mapping[str, type]] = None):
+        self.deserialize_type = {
+            "iso-8601": Deserializer.deserialize_iso,
+            "rfc-1123": Deserializer.deserialize_rfc,
+            "unix-time": Deserializer.deserialize_unix,
+            "duration": Deserializer.deserialize_duration,
+            "date": Deserializer.deserialize_date,
+            "time": Deserializer.deserialize_time,
+            "decimal": Deserializer.deserialize_decimal,
+            "long": Deserializer.deserialize_long,
+            "bytearray": Deserializer.deserialize_bytearray,
+            "base64": Deserializer.deserialize_base64,
+            "object": self.deserialize_object,
+            "[]": self.deserialize_iter,
+            "{}": self.deserialize_dict,
+        }
+        self.deserialize_expected_types = {
+            "duration": (isodate.Duration, datetime.timedelta),
+            "iso-8601": (datetime.datetime),
+        }
+        self.dependencies: Dict[str, type] = dict(classes) if classes else {}
+        self.key_extractors = [rest_key_extractor, xml_key_extractor]
+        # Additional properties only works if the "rest_key_extractor" is used to
+        # extract the keys. Making it to work whatever the key extractor is too much
+        # complicated, with no real scenario for now.
+        # So adding a flag to disable additional properties detection. This flag should be
+        # used if your expect the deserialization to NOT come from a JSON REST syntax.
+        # Otherwise, result are unexpected
+        self.additional_properties_detection = True
+
+    def __call__(self, target_obj, response_data, content_type=None):
+        """Call the deserializer to process a REST response.
+
+        :param str target_obj: Target data type to deserialize to.
+        :param requests.Response response_data: REST response object.
+        :param str content_type: Swagger "produces" if available.
+        :raises: DeserializationError if deserialization fails.
+        :return: Deserialized object.
+        """
+        data = self._unpack_content(response_data, content_type)
+        return self._deserialize(target_obj, data)
+
+    def _deserialize(self, target_obj, data):
+        """Call the deserializer on a model.
+
+        Data needs to be already deserialized as JSON or XML ElementTree
+
+        :param str target_obj: Target data type to deserialize to.
+        :param object data: Object to deserialize.
+        :raises: DeserializationError if deserialization fails.
+        :return: Deserialized object.
+        """
+        # This is already a model, go recursive just in case
+        if hasattr(data, "_attribute_map"):
+            constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")]
+            try:
+                for attr, mapconfig in data._attribute_map.items():
+                    if attr in constants:
+                        continue
+                    value = getattr(data, attr)
+                    if value is None:
+                        continue
+                    local_type = mapconfig["type"]
+                    internal_data_type = local_type.strip("[]{}")
+                    if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum):
+                        continue
+                    setattr(data, attr, self._deserialize(local_type, value))
+                return data
+            except AttributeError:
+                return
+
+        response, class_name = self._classify_target(target_obj, data)
+
+        if isinstance(response, str):
+            return self.deserialize_data(data, response)
+        elif isinstance(response, type) and issubclass(response, Enum):
+            return self.deserialize_enum(data, response)
+
+        if data is None:
+            return data
+        try:
+            attributes = response._attribute_map  # type: ignore
+            d_attrs = {}
+            for attr, attr_desc in attributes.items():
+                # Check empty string. If it's not empty, someone has a real "additionalProperties"...
+                if attr == "additional_properties" and attr_desc["key"] == "":
+                    continue
+                raw_value = None
+                # Enhance attr_desc with some dynamic data
+                attr_desc = attr_desc.copy()  # Do a copy, do not change the real one
+                internal_data_type = attr_desc["type"].strip("[]{}")
+                if internal_data_type in self.dependencies:
+                    attr_desc["internalType"] = self.dependencies[internal_data_type]
+
+                for key_extractor in self.key_extractors:
+                    found_value = key_extractor(attr, attr_desc, data)
+                    if found_value is not None:
+                        if raw_value is not None and raw_value != found_value:
+                            msg = (
+                                "Ignoring extracted value '%s' from %s for key '%s'"
+                                " (duplicate extraction, follow extractors order)"
+                            )
+                            _LOGGER.warning(msg, found_value, key_extractor, attr)
+                            continue
+                        raw_value = found_value
+
+                value = self.deserialize_data(raw_value, attr_desc["type"])
+                d_attrs[attr] = value
+        except (AttributeError, TypeError, KeyError) as err:
+            msg = "Unable to deserialize to object: " + class_name  # type: ignore
+            raise DeserializationError(msg) from err
+        else:
+            additional_properties = self._build_additional_properties(attributes, data)
+            return self._instantiate_model(response, d_attrs, additional_properties)
+
+    def _build_additional_properties(self, attribute_map, data):
+        if not self.additional_properties_detection:
+            return None
+        if "additional_properties" in attribute_map and attribute_map.get("additional_properties", {}).get("key") != "":
+            # Check empty string. If it's not empty, someone has a real "additionalProperties"
+            return None
+        if isinstance(data, ET.Element):
+            data = {el.tag: el.text for el in data}
+
+        known_keys = {
+            _decode_attribute_map_key(_FLATTEN.split(desc["key"])[0])
+            for desc in attribute_map.values()
+            if desc["key"] != ""
+        }
+        present_keys = set(data.keys())
+        missing_keys = present_keys - known_keys
+        return {key: data[key] for key in missing_keys}
+
+    def _classify_target(self, target, data):
+        """Check to see whether the deserialization target object can
+        be classified into a subclass.
+        Once classification has been determined, initialize object.
+
+        :param str target: The target object type to deserialize to.
+        :param str/dict data: The response data to deserialize.
+        """
+        if target is None:
+            return None, None
+
+        if isinstance(target, str):
+            try:
+                target = self.dependencies[target]
+            except KeyError:
+                return target, target
+
+        try:
+            target = target._classify(data, self.dependencies)  # type: ignore
+        except AttributeError:
+            pass  # Target is not a Model, no classify
+        return target, target.__class__.__name__  # type: ignore
+
+    def failsafe_deserialize(self, target_obj, data, content_type=None):
+        """Ignores any errors encountered in deserialization,
+        and falls back to not deserializing the object. Recommended
+        for use in error deserialization, as we want to return the
+        HttpResponseError to users, and not have them deal with
+        a deserialization error.
+
+        :param str target_obj: The target object type to deserialize to.
+        :param str/dict data: The response data to deserialize.
+        :param str content_type: Swagger "produces" if available.
+        """
+        try:
+            return self(target_obj, data, content_type=content_type)
+        except:
+            _LOGGER.debug(
+                "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
+            )
+            return None
+
+    @staticmethod
+    def _unpack_content(raw_data, content_type=None):
+        """Extract the correct structure for deserialization.
+
+        If raw_data is a PipelineResponse, try to extract the result of RawDeserializer.
+        if we can't, raise. Your Pipeline should have a RawDeserializer.
+
+        If not a pipeline response and raw_data is bytes or string, use content-type
+        to decode it. If no content-type, try JSON.
+
+        If raw_data is something else, bypass all logic and return it directly.
+
+        :param raw_data: Data to be processed.
+        :param content_type: How to parse if raw_data is a string/bytes.
+        :raises JSONDecodeError: If JSON is requested and parsing is impossible.
+        :raises UnicodeDecodeError: If bytes is not UTF8
+        """
+        # Assume this is enough to detect a Pipeline Response without importing it
+        context = getattr(raw_data, "context", {})
+        if context:
+            if RawDeserializer.CONTEXT_NAME in context:
+                return context[RawDeserializer.CONTEXT_NAME]
+            raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize")
+
+        # Assume this is enough to recognize universal_http.ClientResponse without importing it
+        if hasattr(raw_data, "body"):
+            return RawDeserializer.deserialize_from_http_generics(raw_data.text(), raw_data.headers)
+
+        # Assume this enough to recognize requests.Response without importing it.
+        if hasattr(raw_data, "_content_consumed"):
+            return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers)
+
+        if isinstance(raw_data, (str, bytes)) or hasattr(raw_data, "read"):
+            return RawDeserializer.deserialize_from_text(raw_data, content_type)  # type: ignore
+        return raw_data
+
+    def _instantiate_model(self, response, attrs, additional_properties=None):
+        """Instantiate a response model passing in deserialized args.
+
+        :param response: The response model class.
+        :param d_attrs: The deserialized response attributes.
+        """
+        if callable(response):
+            subtype = getattr(response, "_subtype_map", {})
+            try:
+                readonly = [k for k, v in response._validation.items() if v.get("readonly")]
+                const = [k for k, v in response._validation.items() if v.get("constant")]
+                kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const}
+                response_obj = response(**kwargs)
+                for attr in readonly:
+                    setattr(response_obj, attr, attrs.get(attr))
+                if additional_properties:
+                    response_obj.additional_properties = additional_properties
+                return response_obj
+            except TypeError as err:
+                msg = "Unable to deserialize {} into model {}. ".format(kwargs, response)  # type: ignore
+                raise DeserializationError(msg + str(err))
+        else:
+            try:
+                for attr, value in attrs.items():
+                    setattr(response, attr, value)
+                return response
+            except Exception as exp:
+                msg = "Unable to populate response model. "
+                msg += "Type: {}, Error: {}".format(type(response), exp)
+                raise DeserializationError(msg)
+
+    def deserialize_data(self, data, data_type):
+        """Process data for deserialization according to data type.
+
+        :param str data: The response string to be deserialized.
+        :param str data_type: The type to deserialize to.
+        :raises: DeserializationError if deserialization fails.
+        :return: Deserialized object.
+        """
+        if data is None:
+            return data
+
+        try:
+            if not data_type:
+                return data
+            if data_type in self.basic_types.values():
+                return self.deserialize_basic(data, data_type)
+            if data_type in self.deserialize_type:
+                if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
+                    return data
+
+                is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"]
+                if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
+                    return None
+                data_val = self.deserialize_type[data_type](data)
+                return data_val
+
+            iter_type = data_type[0] + data_type[-1]
+            if iter_type in self.deserialize_type:
+                return self.deserialize_type[iter_type](data, data_type[1:-1])
+
+            obj_type = self.dependencies[data_type]
+            if issubclass(obj_type, Enum):
+                if isinstance(data, ET.Element):
+                    data = data.text
+                return self.deserialize_enum(data, obj_type)
+
+        except (ValueError, TypeError, AttributeError) as err:
+            msg = "Unable to deserialize response data."
+            msg += " Data: {}, {}".format(data, data_type)
+            raise DeserializationError(msg) from err
+        else:
+            return self._deserialize(obj_type, data)
+
+    def deserialize_iter(self, attr, iter_type):
+        """Deserialize an iterable.
+
+        :param list attr: Iterable to be deserialized.
+        :param str iter_type: The type of object in the iterable.
+        :rtype: list
+        """
+        if attr is None:
+            return None
+        if isinstance(attr, ET.Element):  # If I receive an element here, get the children
+            attr = list(attr)
+        if not isinstance(attr, (list, set)):
+            raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(iter_type, type(attr)))
+        return [self.deserialize_data(a, iter_type) for a in attr]
+
+    def deserialize_dict(self, attr, dict_type):
+        """Deserialize a dictionary.
+
+        :param dict/list attr: Dictionary to be deserialized. Also accepts
+         a list of key, value pairs.
+        :param str dict_type: The object type of the items in the dictionary.
+        :rtype: dict
+        """
+        if isinstance(attr, list):
+            return {x["key"]: self.deserialize_data(x["value"], dict_type) for x in attr}
+
+        if isinstance(attr, ET.Element):
+            # Transform <Key>value</Key> into {"Key": "value"}
+            attr = {el.tag: el.text for el in attr}
+        return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
+
+    def deserialize_object(self, attr, **kwargs):
+        """Deserialize a generic object.
+        This will be handled as a dictionary.
+
+        :param dict attr: Dictionary to be deserialized.
+        :rtype: dict
+        :raises: TypeError if non-builtin datatype encountered.
+        """
+        if attr is None:
+            return None
+        if isinstance(attr, ET.Element):
+            # Do no recurse on XML, just return the tree as-is
+            return attr
+        if isinstance(attr, str):
+            return self.deserialize_basic(attr, "str")
+        obj_type = type(attr)
+        if obj_type in self.basic_types:
+            return self.deserialize_basic(attr, self.basic_types[obj_type])
+        if obj_type is _long_type:
+            return self.deserialize_long(attr)
+
+        if obj_type == dict:
+            deserialized = {}
+            for key, value in attr.items():
+                try:
+                    deserialized[key] = self.deserialize_object(value, **kwargs)
+                except ValueError:
+                    deserialized[key] = None
+            return deserialized
+
+        if obj_type == list:
+            deserialized = []
+            for obj in attr:
+                try:
+                    deserialized.append(self.deserialize_object(obj, **kwargs))
+                except ValueError:
+                    pass
+            return deserialized
+
+        else:
+            error = "Cannot deserialize generic object with type: "
+            raise TypeError(error + str(obj_type))
+
+    def deserialize_basic(self, attr, data_type):
+        """Deserialize basic builtin data type from string.
+        Will attempt to convert to str, int, float and bool.
+        This function will also accept '1', '0', 'true' and 'false' as
+        valid bool values.
+
+        :param str attr: response string to be deserialized.
+        :param str data_type: deserialization data type.
+        :rtype: str, int, float or bool
+        :raises: TypeError if string format is not valid.
+        """
+        # If we're here, data is supposed to be a basic type.
+        # If it's still an XML node, take the text
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+            if not attr:
+                if data_type == "str":
+                    # None or '', node <a/> is empty string.
+                    return ""
+                else:
+                    # None or '', node <a/> with a strong type is None.
+                    # Don't try to model "empty bool" or "empty int"
+                    return None
+
+        if data_type == "bool":
+            if attr in [True, False, 1, 0]:
+                return bool(attr)
+            elif isinstance(attr, str):
+                if attr.lower() in ["true", "1"]:
+                    return True
+                elif attr.lower() in ["false", "0"]:
+                    return False
+            raise TypeError("Invalid boolean value: {}".format(attr))
+
+        if data_type == "str":
+            return self.deserialize_unicode(attr)
+        return eval(data_type)(attr)  # nosec
+
+    @staticmethod
+    def deserialize_unicode(data):
+        """Preserve unicode objects in Python 2, otherwise return data
+        as a string.
+
+        :param str data: response string to be deserialized.
+        :rtype: str or unicode
+        """
+        # We might be here because we have an enum modeled as string,
+        # and we try to deserialize a partial dict with enum inside
+        if isinstance(data, Enum):
+            return data
+
+        # Consider this is real string
+        try:
+            if isinstance(data, unicode):  # type: ignore
+                return data
+        except NameError:
+            return str(data)
+        else:
+            return str(data)
+
+    @staticmethod
+    def deserialize_enum(data, enum_obj):
+        """Deserialize string into enum object.
+
+        If the string is not a valid enum value it will be returned as-is
+        and a warning will be logged.
+
+        :param str data: Response string to be deserialized. If this value is
+         None or invalid it will be returned as-is.
+        :param Enum enum_obj: Enum object to deserialize to.
+        :rtype: Enum
+        """
+        if isinstance(data, enum_obj) or data is None:
+            return data
+        if isinstance(data, Enum):
+            data = data.value
+        if isinstance(data, int):
+            # Workaround. We might consider remove it in the future.
+            try:
+                return list(enum_obj.__members__.values())[data]
+            except IndexError:
+                error = "{!r} is not a valid index for enum {!r}"
+                raise DeserializationError(error.format(data, enum_obj))
+        try:
+            return enum_obj(str(data))
+        except ValueError:
+            for enum_value in enum_obj:
+                if enum_value.value.lower() == str(data).lower():
+                    return enum_value
+            # We don't fail anymore for unknown value, we deserialize as a string
+            _LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj)
+            return Deserializer.deserialize_unicode(data)
+
+    @staticmethod
+    def deserialize_bytearray(attr):
+        """Deserialize string into bytearray.
+
+        :param str attr: response string to be deserialized.
+        :rtype: bytearray
+        :raises: TypeError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        return bytearray(b64decode(attr))  # type: ignore
+
+    @staticmethod
+    def deserialize_base64(attr):
+        """Deserialize base64 encoded string into string.
+
+        :param str attr: response string to be deserialized.
+        :rtype: bytearray
+        :raises: TypeError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        padding = "=" * (3 - (len(attr) + 3) % 4)  # type: ignore
+        attr = attr + padding  # type: ignore
+        encoded = attr.replace("-", "+").replace("_", "/")
+        return b64decode(encoded)
+
+    @staticmethod
+    def deserialize_decimal(attr):
+        """Deserialize string into Decimal object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Decimal
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            return decimal.Decimal(str(attr))  # type: ignore
+        except decimal.DecimalException as err:
+            msg = "Invalid decimal {}".format(attr)
+            raise DeserializationError(msg) from err
+
+    @staticmethod
+    def deserialize_long(attr):
+        """Deserialize string into long (Py2) or int (Py3).
+
+        :param str attr: response string to be deserialized.
+        :rtype: long or int
+        :raises: ValueError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        return _long_type(attr)  # type: ignore
+
+    @staticmethod
+    def deserialize_duration(attr):
+        """Deserialize ISO-8601 formatted string into TimeDelta object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: TimeDelta
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            duration = isodate.parse_duration(attr)
+        except (ValueError, OverflowError, AttributeError) as err:
+            msg = "Cannot deserialize duration object."
+            raise DeserializationError(msg) from err
+        else:
+            return duration
+
+    @staticmethod
+    def deserialize_date(attr):
+        """Deserialize ISO-8601 formatted string into Date object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Date
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        if re.search(r"[^\W\d_]", attr, re.I + re.U):  # type: ignore
+            raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
+        # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
+        return isodate.parse_date(attr, defaultmonth=0, defaultday=0)
+
+    @staticmethod
+    def deserialize_time(attr):
+        """Deserialize ISO-8601 formatted string into time object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: datetime.time
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        if re.search(r"[^\W\d_]", attr, re.I + re.U):  # type: ignore
+            raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
+        return isodate.parse_time(attr)
+
+    @staticmethod
+    def deserialize_rfc(attr):
+        """Deserialize RFC-1123 formatted string into Datetime object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Datetime
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            parsed_date = email.utils.parsedate_tz(attr)  # type: ignore
+            date_obj = datetime.datetime(
+                *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
+            )
+            if not date_obj.tzinfo:
+                date_obj = date_obj.astimezone(tz=TZ_UTC)
+        except ValueError as err:
+            msg = "Cannot deserialize to rfc datetime object."
+            raise DeserializationError(msg) from err
+        else:
+            return date_obj
+
+    @staticmethod
+    def deserialize_iso(attr):
+        """Deserialize ISO-8601 formatted string into Datetime object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Datetime
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            attr = attr.upper()  # type: ignore
+            match = Deserializer.valid_date.match(attr)
+            if not match:
+                raise ValueError("Invalid datetime string: " + attr)
+
+            check_decimal = attr.split(".")
+            if len(check_decimal) > 1:
+                decimal_str = ""
+                for digit in check_decimal[1]:
+                    if digit.isdigit():
+                        decimal_str += digit
+                    else:
+                        break
+                if len(decimal_str) > 6:
+                    attr = attr.replace(decimal_str, decimal_str[0:6])
+
+            date_obj = isodate.parse_datetime(attr)
+            test_utc = date_obj.utctimetuple()
+            if test_utc.tm_year > 9999 or test_utc.tm_year < 1:
+                raise OverflowError("Hit max or min date")
+        except (ValueError, OverflowError, AttributeError) as err:
+            msg = "Cannot deserialize datetime object."
+            raise DeserializationError(msg) from err
+        else:
+            return date_obj
+
+    @staticmethod
+    def deserialize_unix(attr):
+        """Serialize Datetime object into IntTime format.
+        This is represented as seconds.
+
+        :param int attr: Object to be serialized.
+        :rtype: Datetime
+        :raises: DeserializationError if format invalid
+        """
+        if isinstance(attr, ET.Element):
+            attr = int(attr.text)  # type: ignore
+        try:
+            attr = int(attr)
+            date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC)
+        except ValueError as err:
+            msg = "Cannot deserialize to unix datetime object."
+            raise DeserializationError(msg) from err
+        else:
+            return date_obj
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_vendor.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_vendor.py
new file mode 100644
index 0000000000000..cea1829f79e31
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_vendor.py
@@ -0,0 +1,26 @@
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from abc import ABC
+from typing import TYPE_CHECKING
+
+from ._configuration import RadiologyInsightsClientConfiguration
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core import PipelineClient
+
+    from ._serialization import Deserializer, Serializer
+
+
+class RadiologyInsightsClientMixinABC(ABC):
+    """DO NOT use this class. It is for internal typing use only."""
+
+    _client: "PipelineClient"
+    _config: RadiologyInsightsClientConfiguration
+    _serialize: "Serializer"
+    _deserialize: "Deserializer"
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_version.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_version.py
new file mode 100644
index 0000000000000..0ec13ea52bbf5
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/_version.py
@@ -0,0 +1,9 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+VERSION = "1.0.0"
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/__init__.py
new file mode 100644
index 0000000000000..3a05b0feea6f6
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/__init__.py
@@ -0,0 +1,23 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._client import RadiologyInsightsClient
+
+try:
+    from ._patch import __all__ as _patch_all
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+except ImportError:
+    _patch_all = []
+from ._patch import patch_sdk as _patch_sdk
+
+__all__ = [
+    "RadiologyInsightsClient",
+]
+__all__.extend([p for p in _patch_all if p not in __all__])
+
+_patch_sdk()
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_client.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_client.py
new file mode 100644
index 0000000000000..ab2f8cd2fc98c
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_client.py
@@ -0,0 +1,101 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from copy import deepcopy
+from typing import Any, Awaitable
+
+from azure.core import AsyncPipelineClient
+from azure.core.credentials import AzureKeyCredential
+from azure.core.pipeline import policies
+from azure.core.rest import AsyncHttpResponse, HttpRequest
+
+from .._serialization import Deserializer, Serializer
+from ._configuration import RadiologyInsightsClientConfiguration
+from ._operations import RadiologyInsightsClientOperationsMixin
+
+
+class RadiologyInsightsClient(
+    RadiologyInsightsClientOperationsMixin
+):  # pylint: disable=client-accepts-api-version-keyword
+    """RadiologyInsightsClient.
+
+    :param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
+     https://westus2.api.cognitive.microsoft.com). Required.
+    :type endpoint: str
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.AzureKeyCredential
+    :keyword api_version: The API version to use for this operation. Default value is "2024-04-01".
+     Note that overriding this default value may result in unsupported behavior.
+    :paramtype api_version: str
+    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
+     Retry-After header is present.
+    """
+
+    def __init__(self, endpoint: str, credential: AzureKeyCredential, **kwargs: Any) -> None:
+        _endpoint = "{endpoint}/health-insights"
+        self._config = RadiologyInsightsClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
+        _policies = kwargs.pop("policies", None)
+        if _policies is None:
+            _policies = [
+                policies.RequestIdPolicy(**kwargs),
+                self._config.headers_policy,
+                self._config.user_agent_policy,
+                self._config.proxy_policy,
+                policies.ContentDecodePolicy(**kwargs),
+                self._config.redirect_policy,
+                self._config.retry_policy,
+                self._config.authentication_policy,
+                self._config.custom_hook_policy,
+                self._config.logging_policy,
+                policies.DistributedTracingPolicy(**kwargs),
+                policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+                self._config.http_logging_policy,
+            ]
+        self._client: AsyncPipelineClient = AsyncPipelineClient(base_url=_endpoint, policies=_policies, **kwargs)
+
+        self._serialize = Serializer()
+        self._deserialize = Deserializer()
+        self._serialize.client_side_validation = False
+
+    def send_request(
+        self, request: HttpRequest, *, stream: bool = False, **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/dpcodegen/python/send_request
+
+        :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)
+        path_format_arguments = {
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
+        }
+
+        request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
+
+    async def close(self) -> None:
+        await self._client.close()
+
+    async def __aenter__(self) -> "RadiologyInsightsClient":
+        await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, *exc_details: Any) -> None:
+        await self._client.__aexit__(*exc_details)
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_configuration.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_configuration.py
new file mode 100644
index 0000000000000..83d6029b7ed6c
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_configuration.py
@@ -0,0 +1,61 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from typing import Any
+
+from azure.core.credentials import AzureKeyCredential
+from azure.core.pipeline import policies
+
+from .._version import VERSION
+
+
+class RadiologyInsightsClientConfiguration:  # pylint: disable=too-many-instance-attributes,name-too-long
+    """Configuration for RadiologyInsightsClient.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+
+    :param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
+     https://westus2.api.cognitive.microsoft.com). Required.
+    :type endpoint: str
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.AzureKeyCredential
+    :keyword api_version: The API version to use for this operation. Default value is "2024-04-01".
+     Note that overriding this default value may result in unsupported behavior.
+    :paramtype api_version: str
+    """
+
+    def __init__(self, endpoint: str, credential: AzureKeyCredential, **kwargs: Any) -> None:
+        api_version: str = kwargs.pop("api_version", "2024-04-01")
+
+        if endpoint is None:
+            raise ValueError("Parameter 'endpoint' must not be None.")
+        if credential is None:
+            raise ValueError("Parameter 'credential' must not be None.")
+
+        self.endpoint = endpoint
+        self.credential = credential
+        self.api_version = api_version
+        kwargs.setdefault("sdk_moniker", "healthinsights-radiologyinsights/{}".format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
+        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 policies.HttpLoggingPolicy(**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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs)
+        self.authentication_policy = kwargs.get("authentication_policy")
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = policies.AzureKeyCredentialPolicy(
+                self.credential, "Ocp-Apim-Subscription-Key", **kwargs
+            )
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/__init__.py
new file mode 100644
index 0000000000000..24be3b0c64fce
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/__init__.py
@@ -0,0 +1,19 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._operations import RadiologyInsightsClientOperationsMixin
+
+from ._patch import __all__ as _patch_all
+from ._patch import *  # pylint: disable=unused-wildcard-import
+from ._patch import patch_sdk as _patch_sdk
+
+__all__ = [
+    "RadiologyInsightsClientOperationsMixin",
+]
+__all__.extend([p for p in _patch_all if p not in __all__])
+_patch_sdk()
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/_operations.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/_operations.py
new file mode 100644
index 0000000000000..23ecc3a89c0ba
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/_operations.py
@@ -0,0 +1,6660 @@
+# pylint: disable=too-many-lines,too-many-statements
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+from io import IOBase
+import json
+import sys
+from typing import Any, Callable, Dict, IO, List, Optional, TypeVar, Union, cast, overload
+
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceExistsError,
+    ResourceNotFoundError,
+    ResourceNotModifiedError,
+    map_error,
+)
+from azure.core.pipeline import PipelineResponse
+from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod
+from azure.core.polling.async_base_polling import AsyncLROBasePolling
+from azure.core.rest import AsyncHttpResponse, HttpRequest
+from azure.core.tracing.decorator_async import distributed_trace_async
+from azure.core.utils import case_insensitive_dict
+
+from ... import models as _models
+from ..._model_base import SdkJSONEncoder, _deserialize
+from ..._operations._operations import build_radiology_insights_infer_radiology_insights_request
+from .._vendor import RadiologyInsightsClientMixinABC
+
+if sys.version_info >= (3, 9):
+    from collections.abc import MutableMapping
+else:
+    from typing import MutableMapping  # type: ignore  # pylint: disable=ungrouped-imports
+JSON = MutableMapping[str, Any]  # pylint: disable=unsubscriptable-object
+T = TypeVar("T")
+ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
+
+
+class RadiologyInsightsClientOperationsMixin(RadiologyInsightsClientMixinABC):
+    async def _infer_radiology_insights_initial(
+        self,
+        id: str,
+        resource: Union[_models.RadiologyInsightsJob, JSON, IO[bytes]],
+        *,
+        expand: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> JSON:
+        error_map = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        content_type = content_type or "application/json"
+        _content = None
+        if isinstance(resource, (IOBase, bytes)):
+            _content = resource
+        else:
+            _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
+
+        _request = build_radiology_insights_infer_radiology_insights_request(
+            id=id,
+            expand=expand,
+            content_type=content_type,
+            api_version=self._config.api_version,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        path_format_arguments = {
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
+        }
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+        _stream = False
+        pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200, 201]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)
+            error = _deserialize(_models.HealthInsightsErrorResponse, response.json())
+            raise HttpResponseError(response=response, model=error)
+
+        response_headers = {}
+        if response.status_code == 200:
+            response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
+            response_headers["Operation-Location"] = self._deserialize(
+                "str", response.headers.get("Operation-Location")
+            )
+
+            deserialized = _deserialize(JSON, response.json())
+
+        if response.status_code == 201:
+            response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
+            response_headers["Operation-Location"] = self._deserialize(
+                "str", response.headers.get("Operation-Location")
+            )
+
+            deserialized = _deserialize(JSON, response.json())
+
+        if cls:
+            return cls(pipeline_response, deserialized, response_headers)  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @overload
+    async def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: _models.RadiologyInsightsJob,
+        *,
+        expand: Optional[List[str]] = None,
+        content_type: str = "application/json",
+        **kwargs: Any
+    ) -> AsyncLROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Required.
+        :type resource: ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: An instance of AsyncLROPoller that returns RadiologyInsightsJob. The
+         RadiologyInsightsJob is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.AsyncLROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                resource = {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+
+    @overload
+    async def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: JSON,
+        *,
+        expand: Optional[List[str]] = None,
+        content_type: str = "application/json",
+        **kwargs: Any
+    ) -> AsyncLROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Required.
+        :type resource: JSON
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: An instance of AsyncLROPoller that returns RadiologyInsightsJob. The
+         RadiologyInsightsJob is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.AsyncLROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+
+    @overload
+    async def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: IO[bytes],
+        *,
+        expand: Optional[List[str]] = None,
+        content_type: str = "application/json",
+        **kwargs: Any
+    ) -> AsyncLROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Required.
+        :type resource: IO[bytes]
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: An instance of AsyncLROPoller that returns RadiologyInsightsJob. The
+         RadiologyInsightsJob is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.AsyncLROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+
+    @distributed_trace_async
+    async def begin_infer_radiology_insights(
+        self,
+        id: str,
+        resource: Union[_models.RadiologyInsightsJob, JSON, IO[bytes]],
+        *,
+        expand: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> AsyncLROPoller[_models.RadiologyInsightsJob]:
+        # pylint: disable=line-too-long
+        """Create Radiology Insights job.
+
+        Creates a Radiology Insights job with the given request body.
+
+        :param id: The unique ID of the job. Required.
+        :type id: str
+        :param resource: The resource instance. Is one of the following types: RadiologyInsightsJob,
+         JSON, IO[bytes] Required.
+        :type resource: ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob or JSON or
+         IO[bytes]
+        :keyword expand: Expand the indicated resources into the response. Default value is None.
+        :paramtype expand: list[str]
+        :return: An instance of AsyncLROPoller that returns RadiologyInsightsJob. The
+         RadiologyInsightsJob is compatible with MutableMapping
+        :rtype:
+         ~azure.core.polling.AsyncLROPoller[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                resource = {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+
+                # response body for status code(s): 201, 200
+                response == {
+                    "status": "str",  # The status of the job. Required. Known values are:
+                      "notStarted", "running", "succeeded", "failed", and "canceled".
+                    "createdAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job was created.
+                    "error": {
+                        "code": "str",  # One of a server-defined set of error codes.
+                          Required.
+                        "message": "str",  # A human-readable representation of the error.
+                          Required.
+                        "details": [
+                            ...
+                        ],
+                        "innererror": {
+                            "code": "str",  # Optional. One of a server-defined set of
+                              error codes.
+                            "innererror": ...
+                        },
+                        "target": "str"  # Optional. The target of the error.
+                    },
+                    "expiresAt": "2020-02-20 00:00:00",  # Optional. The date and time when the
+                      processing job is set to expire.
+                    "jobData": {
+                        "patients": [
+                            {
+                                "id": "str",  # A given identifier for the patient.
+                                  Has to be unique across all patients in a single request. Required.
+                                "details": {
+                                    "birthDate": "2020-02-20",  # Optional. The
+                                      patient's date of birth.
+                                    "clinicalInfo": [
+                                        {
+                                            "resourceType": "str",  # The
+                                              type of resource. Required.
+                                            "id": "str",  # Optional.
+                                              Resource Id.
+                                            "implicitRules": "str",  #
+                                              Optional. A set of rules under which this content was
+                                              created.
+                                            "language": "str",  #
+                                              Optional. Language of the resource content.
+                                            "meta": {
+                                                "lastUpdated": "str",
+                                                  # Optional. When the resource last changed - e.g.
+                                                  when the version changed.
+                                                "profile": [
+                                                    "str"  #
+                                                      Optional. A list of profiles (references to
+                                                      `StructureDefinition
+                                                      <https://www.hl7.org/fhir/structuredefinition.html>`_
+                                                      resources) that this resource claims to conform
+                                                      to. The URL is a reference to
+                                                      `StructureDefinition.url
+                                                      <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+                                                ],
+                                                "security": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "source": "str",  #
+                                                  Optional. A uri that identifies the source system of
+                                                  the resource. This provides a minimal amount of
+                                                  Provenance information that can be used to track or
+                                                  differentiate the source of information in the
+                                                  resource. The source may identify another FHIR
+                                                  server, document, message, database, etc.
+                                                "tag": [
+                                                    {
+                "code": "str",  # Optional. Symbol in syntax
+                                                          defined by the system.
+                "display": "str",  # Optional. Representation
+                                                          defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of the
+                                                                  definition for the extension code - a
+                                                                  logical name or a URL. Required.
+                "valueBoolean": bool,  # Optional.
+                                                                  Value as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  # Optional. Plain
+                                                                      text representation of the
+                                                                      concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                                  Value as dateTime.
+                "valueInteger": 0,  # Optional. Value
+                                                                  as integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End
+                                                                      time with inclusive boundary, if
+                                                                      not ongoing.
+                "start": "str"  # Optional.
+                                                                      Starting time with inclusive
+                                                                      boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "low": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional.
+                                                                      Text alternative for the
+                                                                      resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "system": "str",  # Optional.
+                                                                          The namespace for the
+                                                                          identifier value.
+                "type": {
+                "coding": [
+                ...
+                ],
+                "text": "str"  #
+                                                                              Optional. Plain text
+                                                                              representation of the
+                                                                              concept.
+                },
+                "use": "str",  # Optional.
+                                                                          usual | official | temp |
+                                                                          secondary | old (If known).
+                "value": "str"  # Optional.
+                                                                          The value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                      Literal reference, Relative,
+                                                                      internal or absolute URL.
+                "type": "str"  # Optional. Type
+                                                                      the reference refers to (e.g.
+                                                                      "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of
+                                                                      sample points at each time point.
+                                                                      Required.
+                "origin": {
+                "code": "str",  # Optional.
+                                                                          Coded form of the unit.
+                "comparator": "str",  #
+                                                                          Optional. < | <= | >= | > -
+                                                                          how to understand the value.
+                "system": "str",  # Optional.
+                                                                          System that defines coded
+                                                                          unit form.
+                "unit": "str",  # Optional.
+                                                                          Unit representation.
+                "value": 0.0  # Optional.
+                                                                          Numerical value (with
+                                                                          implicit precision).
+                },
+                "period": 0.0,  # Number of
+                                                                      milliseconds between samples.
+                                                                      Required.
+                "data": "str",  # Optional.
+                                                                      Decimal values with spaces, or
+                                                                      "E" | "U" | "L".
+                "factor": 0.0,  # Optional.
+                                                                      Multiply data by this before
+                                                                      adding to origin.
+                "lowerLimit": 0.0,  # Optional.
+                                                                      Lower limit of detection.
+                "upperLimit": 0.0  # Optional.
+                                                                      Upper limit of detection.
+                },
+                "valueString": "str",  # Optional.
+                                                                  Value as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                                  Value as time (hh:mm:ss).
+                }
+                                                        ],
+                                                        "id":
+                                                          "str",  # Optional. Unique id for
+                                                          inter-element referencing.
+                "system": "str",  # Optional. Identity of the
+                                                          terminology system.
+                "version": "str"  # Optional. Version of the
+                                                          system - if relevant.
+                                                    }
+                                                ],
+                                                "versionId": "str"  #
+                                                  Optional. The version specific identifier, as it
+                                                  appears in the version portion of the URL. This value
+                                                  changes when the resource is created, updated, or
+                                                  deleted.
+                                            }
+                                        }
+                                    ],
+                                    "sex": "str"  # Optional. The patient's sex.
+                                      Known values are: "female", "male", and "unspecified".
+                                },
+                                "encounters": [
+                                    {
+                                        "id": "str",  # The id of the visit.
+                                          Required.
+                                        "class": "str",  # Optional. The
+                                          class of the encounter. Known values are: "inpatient",
+                                          "ambulatory", "observation", "emergency", "virtual", and
+                                          "healthHome".
+                                        "period": {
+                                            "end": "2020-02-20 00:00:00",
+                                              # Optional. End time with inclusive boundary, if not
+                                              ongoing.
+                                            "start": "2020-02-20
+                                              00:00:00"  # Optional. Starting time with inclusive
+                                              boundary.
+                                        }
+                                    }
+                                ],
+                                "patientDocuments": [
+                                    {
+                                        "content": {
+                                            "sourceType": "str",  # The
+                                              type of the content's source. In case the source type is
+                                              'inline', the content is given as a string (for instance,
+                                              text). In case the source type is 'reference', the
+                                              content is given as a URI. Required. Known values are:
+                                              "inline" and "reference".
+                                            "value": "str"  # The content
+                                              of the document, given either inline (as a string) or as
+                                              a reference (URI). Required.
+                                        },
+                                        "id": "str",  # A given identifier
+                                          for the document. Has to be unique across all documents for a
+                                          single patient. Required.
+                                        "type": "str",  # The type of the
+                                          patient document, such as 'note' (text document) or
+                                          'fhirBundle' (FHIR JSON document). Required. Known values
+                                          are: "note", "fhirBundle", "dicom", and "genomicSequencing".
+                                        "administrativeMetadata": {
+                                            "encounterId": "str",  #
+                                              Optional. Reference to the encounter associated with the
+                                              document.
+                                            "orderedProcedures": [
+                                                {
+                                                    "code": {
+                "coding": [
+                {
+                "code": "str",  # Optional. Symbol in
+                                                                  syntax defined by the system.
+                "display": "str",  # Optional.
+                                                                  Representation defined by the system.
+                "extension": [
+                {
+                "url": "str",  # Source of
+                                                                          the definition for the
+                                                                          extension code - a logical
+                                                                          name or a URL. Required.
+                "valueBoolean": bool,  #
+                                                                          Optional. Value as boolean.
+                "valueCodeableConcept": ...,
+                "valueDateTime": "str",  #
+                                                                          Optional. Value as dateTime.
+                "valueInteger": 0,  #
+                                                                          Optional. Value as integer.
+                "valuePeriod": {
+                "end": "str",  #
+                                                                              Optional. End time with
+                                                                              inclusive boundary, if
+                                                                              not ongoing.
+                "start": "str"  #
+                                                                              Optional. Starting time
+                                                                              with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  #
+                                                                              Optional. Coded form of
+                                                                              the unit.
+                "comparator": "str",  #
+                                                                              Optional. < | <= | >= | >
+                                                                              - how to understand the
+                                                                              value.
+                "system": "str",  #
+                                                                              Optional. System that
+                                                                              defines coded unit form.
+                "unit": "str",  #
+                                                                              Optional. Unit
+                                                                              representation.
+                "value": 0.0  # Optional.
+                                                                              Numerical value (with
+                                                                              implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "low": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "numerator": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  #
+                                                                              Optional. Text
+                                                                              alternative for the
+                                                                              resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  #
+                                                                                      Optional. End
+                                                                                      time with
+                                                                                      inclusive
+                                                                                      boundary, if not
+                                                                                      ongoing.
+                "start": "str"  #
+                                                                                      Optional.
+                                                                                      Starting time
+                                                                                      with inclusive
+                                                                                      boundary.
+                },
+                "system": "str",  #
+                                                                                  Optional. The
+                                                                                  namespace for the
+                                                                                  identifier value.
+                "type": ...,
+                "use": "str",  #
+                                                                                  Optional. usual |
+                                                                                  official | temp |
+                                                                                  secondary | old (If
+                                                                                  known).
+                "value": "str"  #
+                                                                                  Optional. The value
+                                                                                  that is unique.
+                },
+                "reference": "str",  #
+                                                                              Optional. Literal
+                                                                              reference, Relative,
+                                                                              internal or absolute URL.
+                "type": "str"  #
+                                                                              Optional. Type the
+                                                                              reference refers to (e.g.
+                                                                              "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  #
+                                                                              Number of sample points
+                                                                              at each time point.
+                                                                              Required.
+                "origin": {
+                "code": "str",  #
+                                                                                  Optional. Coded form
+                                                                                  of the unit.
+                "comparator": "str",
+                                                                                  # Optional. < | <= |
+                                                                                  >= | > - how to
+                                                                                  understand the value.
+                "system": "str",  #
+                                                                                  Optional. System that
+                                                                                  defines coded unit
+                                                                                  form.
+                "unit": "str",  #
+                                                                                  Optional. Unit
+                                                                                  representation.
+                "value": 0.0  #
+                                                                                  Optional. Numerical
+                                                                                  value (with implicit
+                                                                                  precision).
+                },
+                "period": 0.0,  # Number
+                                                                              of milliseconds between
+                                                                              samples. Required.
+                "data": "str",  #
+                                                                              Optional. Decimal values
+                                                                              with spaces, or "E" | "U"
+                                                                              | "L".
+                "factor": 0.0,  #
+                                                                              Optional. Multiply data
+                                                                              by this before adding to
+                                                                              origin.
+                "lowerLimit": 0.0,  #
+                                                                              Optional. Lower limit of
+                                                                              detection.
+                "upperLimit": 0.0  #
+                                                                              Optional. Upper limit of
+                                                                              detection.
+                },
+                "valueString": "str",  #
+                                                                          Optional. Value as string.
+                "valueTime": "12:30:00"  #
+                                                                          Optional. Value as time
+                                                                          (hh:mm:ss).
+                }
+                ],
+                "id": "str",  # Optional. Unique id
+                                                                  for inter-element referencing.
+                "system": "str",  # Optional.
+                                                                  Identity of the terminology system.
+                "version": "str"  # Optional. Version
+                                                                  of the system - if relevant.
+                }
+                                                        ],
+                "text": "str"  # Optional. Plain text
+                                                          representation of the concept.
+                                                    },
+                "description": "str",  # Optional. Procedure
+                                                      description.
+                                                    "extension":
+                                                      [
+                                                        {
+                "url": "str",  # Source of the definition
+                                                              for the extension code - a logical name
+                                                              or a URL. Required.
+                "valueBoolean": bool,  # Optional. Value
+                                                              as boolean.
+                "valueCodeableConcept": {
+                "coding": [
+                {
+                "code": "str",  # Optional.
+                                                                          Symbol in syntax defined by
+                                                                          the system.
+                "display": "str",  #
+                                                                          Optional. Representation
+                                                                          defined by the system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  # Optional.
+                                                                          Unique id for inter-element
+                                                                          referencing.
+                "system": "str",  # Optional.
+                                                                          Identity of the terminology
+                                                                          system.
+                "version": "str"  # Optional.
+                                                                          Version of the system - if
+                                                                          relevant.
+                }
+                ],
+                "text": "str"  # Optional. Plain text
+                                                                  representation of the concept.
+                },
+                "valueDateTime": "str",  # Optional.
+                                                              Value as dateTime.
+                "valueInteger": 0,  # Optional. Value as
+                                                              integer.
+                "valuePeriod": {
+                "end": "str",  # Optional. End time
+                                                                  with inclusive boundary, if not
+                                                                  ongoing.
+                "start": "str"  # Optional. Starting
+                                                                  time with inclusive boundary.
+                },
+                "valueQuantity": {
+                "code": "str",  # Optional. Coded
+                                                                  form of the unit.
+                "comparator": "str",  # Optional. < |
+                                                                  <= | >= | > - how to understand the
+                                                                  value.
+                "system": "str",  # Optional. System
+                                                                  that defines coded unit form.
+                "unit": "str",  # Optional. Unit
+                                                                  representation.
+                "value": 0.0  # Optional. Numerical
+                                                                  value (with implicit precision).
+                },
+                "valueRange": {
+                "high": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "low": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueRatio": {
+                "denominator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "numerator": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                }
+                },
+                "valueReference": {
+                "display": "str",  # Optional. Text
+                                                                  alternative for the resource.
+                "identifier": {
+                "assigner": ...,
+                "period": {
+                "end": "str",  # Optional.
+                                                                          End time with inclusive
+                                                                          boundary, if not ongoing.
+                "start": "str"  # Optional.
+                                                                          Starting time with inclusive
+                                                                          boundary.
+                },
+                "system": "str",  # Optional. The
+                                                                      namespace for the identifier
+                                                                      value.
+                "type": {
+                "coding": [
+                {
+                "code": "str",  #
+                                                                                  Optional. Symbol in
+                                                                                  syntax defined by the
+                                                                                  system.
+                "display": "str",  #
+                                                                                  Optional.
+                                                                                  Representation
+                                                                                  defined by the
+                                                                                  system.
+                "extension": [
+                ...
+                ],
+                "id": "str",  #
+                                                                                  Optional. Unique id
+                                                                                  for inter-element
+                                                                                  referencing.
+                "system": "str",  #
+                                                                                  Optional. Identity of
+                                                                                  the terminology
+                                                                                  system.
+                "version": "str"  #
+                                                                                  Optional. Version of
+                                                                                  the system - if
+                                                                                  relevant.
+                }
+                ],
+                "text": "str"  # Optional.
+                                                                          Plain text representation of
+                                                                          the concept.
+                },
+                "use": "str",  # Optional. usual
+                                                                      | official | temp | secondary |
+                                                                      old (If known).
+                "value": "str"  # Optional. The
+                                                                      value that is unique.
+                },
+                "reference": "str",  # Optional.
+                                                                  Literal reference, Relative, internal
+                                                                  or absolute URL.
+                "type": "str"  # Optional. Type the
+                                                                  reference refers to (e.g. "Patient").
+                },
+                "valueSampledData": {
+                "dimensions": 0,  # Number of sample
+                                                                  points at each time point. Required.
+                "origin": {
+                "code": "str",  # Optional. Coded
+                                                                      form of the unit.
+                "comparator": "str",  # Optional.
+                                                                      < | <= | >= | > - how to
+                                                                      understand the value.
+                "system": "str",  # Optional.
+                                                                      System that defines coded unit
+                                                                      form.
+                "unit": "str",  # Optional. Unit
+                                                                      representation.
+                "value": 0.0  # Optional.
+                                                                      Numerical value (with implicit
+                                                                      precision).
+                },
+                "period": 0.0,  # Number of
+                                                                  milliseconds between samples.
+                                                                  Required.
+                "data": "str",  # Optional. Decimal
+                                                                  values with spaces, or "E" | "U" |
+                                                                  "L".
+                "factor": 0.0,  # Optional. Multiply
+                                                                  data by this before adding to origin.
+                "lowerLimit": 0.0,  # Optional. Lower
+                                                                  limit of detection.
+                "upperLimit": 0.0  # Optional. Upper
+                                                                  limit of detection.
+                },
+                "valueString": "str",  # Optional. Value
+                                                              as string.
+                "valueTime": "12:30:00"  # Optional.
+                                                              Value as time (hh:mm:ss).
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        "authors": [
+                                            {
+                                                "fullName": "str",  #
+                                                  Optional. Text representation of the full name.
+                                                "id": "str"  #
+                                                  Optional. author id.
+                                            }
+                                        ],
+                                        "clinicalType": "str",  # Optional.
+                                          The type of the clinical document. Known values are:
+                                          "consultation", "dischargeSummary", "historyAndPhysical",
+                                          "radiologyReport", "procedure", "progress", "laboratory", and
+                                          "pathologyReport".
+                                        "createdAt": "2020-02-20 00:00:00",
+                                          # Optional. The date and time when the document was created.
+                                        "language": "str",  # Optional. A 2
+                                          letter ISO 639-1 representation of the language of the
+                                          document.
+                                        "specialtyType": "str"  # Optional.
+                                          specialty type the document. Known values are: "pathology"
+                                          and "radiology".
+                                    }
+                                ]
+                            }
+                        ],
+                        "configuration": {
+                            "includeEvidence": bool,  # Optional. An indication whether
+                              the model's output should include evidence for the inferences.
+                            "inferenceOptions": {
+                                "findingOptions": {
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide the sentence that contains the
+                                      first token of the finding's clinical indicator (i.e. the medical
+                                      problem), if there is one. This sentence is provided as an
+                                      extension with url 'ci_sentence', next to the token evidence.
+                                      Default is false.
+                                },
+                                "followupRecommendationOptions": {
+                                    "includeRecommendationsInReferences": bool,
+                                      # Optional. Include/Exclude follow-up recommendations in
+                                      references to a guideline or article. Default is false.
+                "includeRecommendationsWithNoSpecifiedModality": bool,  #
+                                      Optional. Include/Exclude follow-up recommendations without a
+                                      specific radiology procedure. Default is false.
+                                    "provideFocusedSentenceEvidence": bool  #
+                                      Optional. If this is true, provide one or more sentences as
+                                      evidence for the recommendation, next to the token evidence. The
+                                      start and end positions of these sentences will be put in an
+                                      extension with url 'modality_sentences'. Default is false.
+                                }
+                            },
+                            "inferenceTypes": [
+                                "str"  # Optional. This is a list of inference types
+                                  to be inferred for the current request. It could be used if only part
+                                  of the Radiology Insights inferences are required. If this list is
+                                  omitted or empty, the model will return all the inference types.
+                            ],
+                            "locale": "str",  # Optional. Local for the model to use. If
+                              not specified, the model will use the default locale.
+                            "verbose": bool  # Optional. An indication whether the model
+                              should produce verbose output.
+                        }
+                    },
+                    "result": {
+                        "modelVersion": "str",  # The version of the model used for
+                          inference, expressed as the model date. Required.
+                        "patientResults": [
+                            {
+                                "inferences": [
+                                    radiology_insights_inference
+                                ],
+                                "patientId": "str"  # Identifier given for the
+                                  patient in the request. Required.
+                            }
+                        ]
+                    },
+                    "updatedAt": "2020-02-20 00:00:00"  # Optional. The date and time when the
+                      processing job was last updated.
+                }
+        """
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[_models.RadiologyInsightsJob] = kwargs.pop("cls", None)
+        polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True)
+        lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
+        cont_token: Optional[str] = kwargs.pop("continuation_token", None)
+        if cont_token is None:
+            raw_result = await self._infer_radiology_insights_initial(
+                id=id,
+                resource=resource,
+                expand=expand,
+                content_type=content_type,
+                cls=lambda x, y, z: x,
+                headers=_headers,
+                params=_params,
+                **kwargs
+            )
+        kwargs.pop("error_map", None)
+
+        def get_long_running_output(pipeline_response):
+            response_headers = {}
+            response = pipeline_response.http_response
+            response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
+            response_headers["Operation-Location"] = self._deserialize(
+                "str", response.headers.get("Operation-Location")
+            )
+
+            deserialized = _deserialize(_models.RadiologyInsightsJob, response.json().get("result"))
+            if cls:
+                return cls(pipeline_response, deserialized, response_headers)  # type: ignore
+            return deserialized
+
+        path_format_arguments = {
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
+        }
+
+        if polling is True:
+            polling_method: AsyncPollingMethod = cast(
+                AsyncPollingMethod,
+                AsyncLROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs),
+            )
+        elif polling is False:
+            polling_method = cast(AsyncPollingMethod, AsyncNoPolling())
+        else:
+            polling_method = polling
+        if cont_token:
+            return AsyncLROPoller[_models.RadiologyInsightsJob].from_continuation_token(
+                polling_method=polling_method,
+                continuation_token=cont_token,
+                client=self._client,
+                deserialization_callback=get_long_running_output,
+            )
+        return AsyncLROPoller[_models.RadiologyInsightsJob](
+            self._client, raw_result, get_long_running_output, polling_method  # type: ignore
+        )
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/_patch.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/_patch.py
new file mode 100644
index 0000000000000..f7dd32510333d
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_operations/_patch.py
@@ -0,0 +1,20 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Customize generated code here.
+
+Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
+"""
+from typing import List
+
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+
+
+def patch_sdk():
+    """Do not remove from this file.
+
+    `patch_sdk` is a last resort escape hatch that allows you to do customizations
+    you can't accomplish using the techniques described in
+    https://aka.ms/azsdk/python/dpcodegen/python/customize
+    """
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_patch.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_patch.py
new file mode 100644
index 0000000000000..f7dd32510333d
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_patch.py
@@ -0,0 +1,20 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Customize generated code here.
+
+Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
+"""
+from typing import List
+
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+
+
+def patch_sdk():
+    """Do not remove from this file.
+
+    `patch_sdk` is a last resort escape hatch that allows you to do customizations
+    you can't accomplish using the techniques described in
+    https://aka.ms/azsdk/python/dpcodegen/python/customize
+    """
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_vendor.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_vendor.py
new file mode 100644
index 0000000000000..e2c3b938b89d3
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/aio/_vendor.py
@@ -0,0 +1,26 @@
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from abc import ABC
+from typing import TYPE_CHECKING
+
+from ._configuration import RadiologyInsightsClientConfiguration
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core import AsyncPipelineClient
+
+    from .._serialization import Deserializer, Serializer
+
+
+class RadiologyInsightsClientMixinABC(ABC):
+    """DO NOT use this class. It is for internal typing use only."""
+
+    _client: "AsyncPipelineClient"
+    _config: RadiologyInsightsClientConfiguration
+    _serialize: "Serializer"
+    _deserialize: "Deserializer"
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/__init__.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/__init__.py
new file mode 100644
index 0000000000000..160541b134c26
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/__init__.py
@@ -0,0 +1,179 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._models import AgeMismatchInference
+from ._models import Annotation
+from ._models import CodeableConcept
+from ._models import Coding
+from ._models import CompleteOrderDiscrepancyInference
+from ._models import Condition
+from ._models import ConditionStage
+from ._models import ContactDetail
+from ._models import ContactPoint
+from ._models import CriticalResult
+from ._models import CriticalResultInference
+from ._models import DocumentAdministrativeMetadata
+from ._models import DocumentAuthor
+from ._models import DocumentContent
+from ._models import DomainResource
+from ._models import Element
+from ._models import Error
+from ._models import Extension
+from ._models import FindingInference
+from ._models import FindingOptions
+from ._models import FollowupCommunicationInference
+from ._models import FollowupRecommendationInference
+from ._models import FollowupRecommendationOptions
+from ._models import GenericProcedureRecommendation
+from ._models import HealthInsightsErrorResponse
+from ._models import HealthInsightsErrorResponseRequestId
+from ._models import Identifier
+from ._models import ImagingProcedure
+from ._models import ImagingProcedureRecommendation
+from ._models import InnerError
+from ._models import LateralityDiscrepancyInference
+from ._models import LimitedOrderDiscrepancyInference
+from ._models import Meta
+from ._models import Narrative
+from ._models import Observation
+from ._models import ObservationComponent
+from ._models import ObservationReferenceRange
+from ._models import OrderedProcedure
+from ._models import PatientDetails
+from ._models import PatientDocument
+from ._models import PatientEncounter
+from ._models import PatientRecord
+from ._models import Period
+from ._models import ProcedureRecommendation
+from ._models import Quantity
+from ._models import RadiologyCodeWithTypes
+from ._models import RadiologyInsightsData
+from ._models import RadiologyInsightsInference
+from ._models import RadiologyInsightsInferenceOptions
+from ._models import RadiologyInsightsInferenceResult
+from ._models import RadiologyInsightsJob
+from ._models import RadiologyInsightsModelConfiguration
+from ._models import RadiologyInsightsPatientResult
+from ._models import RadiologyProcedureInference
+from ._models import Range
+from ._models import Ratio
+from ._models import RecommendationFinding
+from ._models import Reference
+from ._models import RequestIdResponseHeader
+from ._models import ResearchStudy
+from ._models import ResearchStudyArm
+from ._models import ResearchStudyObjective
+from ._models import Resource
+from ._models import SampledData
+from ._models import SexMismatchInference
+from ._models import TimePeriod
+
+from ._enums import ClinicalDocumentType
+from ._enums import ContactPointSystem
+from ._enums import ContactPointUse
+from ._enums import DocumentContentSourceType
+from ._enums import DocumentType
+from ._enums import EncounterClass
+from ._enums import JobStatus
+from ._enums import LateralityDiscrepancyType
+from ._enums import MedicalProfessionalType
+from ._enums import ObservationStatusCodeType
+from ._enums import PatientSex
+from ._enums import RadiologyInsightsInferenceType
+from ._enums import RecommendationFindingStatusType
+from ._enums import ResearchStudyStatusCodeType
+from ._enums import SpecialtyType
+from ._patch import __all__ as _patch_all
+from ._patch import *  # pylint: disable=unused-wildcard-import
+from ._patch import patch_sdk as _patch_sdk
+
+__all__ = [
+    "AgeMismatchInference",
+    "Annotation",
+    "CodeableConcept",
+    "Coding",
+    "CompleteOrderDiscrepancyInference",
+    "Condition",
+    "ConditionStage",
+    "ContactDetail",
+    "ContactPoint",
+    "CriticalResult",
+    "CriticalResultInference",
+    "DocumentAdministrativeMetadata",
+    "DocumentAuthor",
+    "DocumentContent",
+    "DomainResource",
+    "Element",
+    "Error",
+    "Extension",
+    "FindingInference",
+    "FindingOptions",
+    "FollowupCommunicationInference",
+    "FollowupRecommendationInference",
+    "FollowupRecommendationOptions",
+    "GenericProcedureRecommendation",
+    "HealthInsightsErrorResponse",
+    "HealthInsightsErrorResponseRequestId",
+    "Identifier",
+    "ImagingProcedure",
+    "ImagingProcedureRecommendation",
+    "InnerError",
+    "LateralityDiscrepancyInference",
+    "LimitedOrderDiscrepancyInference",
+    "Meta",
+    "Narrative",
+    "Observation",
+    "ObservationComponent",
+    "ObservationReferenceRange",
+    "OrderedProcedure",
+    "PatientDetails",
+    "PatientDocument",
+    "PatientEncounter",
+    "PatientRecord",
+    "Period",
+    "ProcedureRecommendation",
+    "Quantity",
+    "RadiologyCodeWithTypes",
+    "RadiologyInsightsData",
+    "RadiologyInsightsInference",
+    "RadiologyInsightsInferenceOptions",
+    "RadiologyInsightsInferenceResult",
+    "RadiologyInsightsJob",
+    "RadiologyInsightsModelConfiguration",
+    "RadiologyInsightsPatientResult",
+    "RadiologyProcedureInference",
+    "Range",
+    "Ratio",
+    "RecommendationFinding",
+    "Reference",
+    "RequestIdResponseHeader",
+    "ResearchStudy",
+    "ResearchStudyArm",
+    "ResearchStudyObjective",
+    "Resource",
+    "SampledData",
+    "SexMismatchInference",
+    "TimePeriod",
+    "ClinicalDocumentType",
+    "ContactPointSystem",
+    "ContactPointUse",
+    "DocumentContentSourceType",
+    "DocumentType",
+    "EncounterClass",
+    "JobStatus",
+    "LateralityDiscrepancyType",
+    "MedicalProfessionalType",
+    "ObservationStatusCodeType",
+    "PatientSex",
+    "RadiologyInsightsInferenceType",
+    "RecommendationFindingStatusType",
+    "ResearchStudyStatusCodeType",
+    "SpecialtyType",
+]
+__all__.extend([p for p in _patch_all if p not in __all__])
+_patch_sdk()
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_enums.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_enums.py
new file mode 100644
index 0000000000000..b0d874d8dc4e1
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_enums.py
@@ -0,0 +1,265 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from enum import Enum
+from azure.core import CaseInsensitiveEnumMeta
+
+
+class ClinicalDocumentType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """The type of the clinical document."""
+
+    CONSULTATION = "consultation"
+    DISCHARGE_SUMMARY = "dischargeSummary"
+    HISTORY_AND_PHYSICAL = "historyAndPhysical"
+    RADIOLOGY_REPORT = "radiologyReport"
+    PROCEDURE = "procedure"
+    PROGRESS = "progress"
+    LABORATORY = "laboratory"
+    PATHOLOGY_REPORT = "pathologyReport"
+
+
+class ContactPointSystem(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Contact Point System
+    see https://www.hl7.org/fhir/R4/valueset-contact-point-system.html.
+    """
+
+    PHONE = "phone"
+    """Phone"""
+    FAX = "fax"
+    """Fax"""
+    EMAIL = "email"
+    """Email"""
+    PAGER = "pager"
+    """Pager"""
+    URL = "url"
+    """Url"""
+    SMS = "sms"
+    """Sms"""
+    OTHER = "other"
+    """Other"""
+
+
+class ContactPointUse(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Contact Point Use
+    See:    http://hl7.org/fhir/ValueSet/contact-point-use.
+    """
+
+    HOME = "home"
+    """Home"""
+    WORK = "work"
+    """Work"""
+    TEMP = "temp"
+    """Temp"""
+    OLD = "old"
+    """Old"""
+    MOBILE = "mobile"
+    """Mobile"""
+
+
+class DocumentContentSourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """The type of the content's source.
+    In case the source type is 'inline', the content is given as a string (for instance, text).
+    In case the source type is 'reference', the content is given as a URI.
+    """
+
+    INLINE = "inline"
+    """The content is given as a string (for instance, text)."""
+    REFERENCE = "reference"
+    """The content is given as a URI."""
+
+
+class DocumentType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """The type of the patient document, such as 'note' (text document) or 'fhirBundle' (FHIR JSON
+    document).
+    """
+
+    NOTE = "note"
+    FHIR_BUNDLE = "fhirBundle"
+    DICOM = "dicom"
+    GENOMIC_SEQUENCING = "genomicSequencing"
+
+
+class EncounterClass(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Known values codes that can be used to indicate the class of encounter (TODO://Based on FHIR
+    value set--http://....).
+    """
+
+    IN_PATIENT = "inpatient"
+    """A patient encounter where a patient is admitted by a hospital or equivalent facility, assigned
+    to a location where patients generally stay at least overnight and provided with room, board,
+    and continuous nursing service."""
+    AMBULATORY = "ambulatory"
+    """The term ambulatory usually implies that the patient has come to the location and is not
+    assigned to a bed. Sometimes referred to as an outpatient encounter."""
+    OBSERVATION = "observation"
+    """An encounter where the patient usually will start in different encounter, such as one in the
+    emergency department but then transition to this type of encounter because they require a
+    significant period of treatment and monitoring to determine whether or not their condition
+    warrants an inpatient admission or discharge."""
+    EMERGENCY = "emergency"
+    """A patient encounter that takes place at a dedicated healthcare service delivery location where
+    the patient receives immediate evaluation and treatment, provided until the patient can be
+    discharged or responsibility for the patient's care is transferred elsewhere (for example, the
+    patient could be admitted as an inpatient or transferred to another facility."""
+    VIRTUAL = "virtual"
+    """A patient encounter where the patient is not physically present for the encounter, such as in a
+    telehealth encounter, phone call, or electronic communication."""
+    HEALTH_HOME = "healthHome"
+    """Healthcare encounter that takes place in the residence of the patient or a designee"""
+
+
+class JobStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """The status of the processing job."""
+
+    NOT_STARTED = "notStarted"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELED = "canceled"
+
+
+class LateralityDiscrepancyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Laterality discrepancy type."""
+
+    ORDER_LATERALITY_MISMATCH = "orderLateralityMismatch"
+    """Mismatch between order and text"""
+    TEXT_LATERALITY_CONTRADICTION = "textLateralityContradiction"
+    """Contradiction in text"""
+    TEXT_LATERALITY_MISSING = "textLateralityMissing"
+    """Missing laterality in text"""
+
+
+class MedicalProfessionalType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Medical Professional Type."""
+
+    UNKNOWN = "unknown"
+    """Unknown medical professional type"""
+    DOCTOR = "doctor"
+    """Doctor medical professional type"""
+    NURSE = "nurse"
+    """Nurse medical professional type"""
+    MIDWIFE = "midwife"
+    """Technician medical professional type"""
+    PHYSICIAN_ASSISTANT = "physicianAssistant"
+    """Technician medical professional type"""
+
+
+class ObservationStatusCodeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Observation Status
+    Based on `FHIR ObservationStatus
+    <https://www.hl7.org/fhir/R4/valueset-observation-status.html>`_.
+    """
+
+    REGISTERED = "registered"
+    """The existence of the observation is registered, but there is no result yet available."""
+    PRELIMINARY = "preliminary"
+    """This is an initial or interim observation: data may be incomplete or unverified."""
+    FINAL = "final"
+    """The observation is complete and verified by an authorized person."""
+    AMENDED = "amended"
+    """Subsequent to being Final, the observation has been modified subsequent.  This includes
+    updates/new information and corrections."""
+    CORRECTED = "corrected"
+    """Subsequent to being Final, the observation has been modified to correct an error in the test
+    result."""
+    CANCELLED = "cancelled"
+    """The observation is unavailable because the measurement was not started or not completed (also
+    sometimes called "aborted")."""
+    ENTERED_IN_ERROR = "entered-in-error"
+    """The observation has been withdrawn following previous final release."""
+    UNKNOWN = "unknown"
+    """The observation status is unknown.  Note that "unknown" is a value of last resort and every
+    attempt should be made to provide a meaningful value other than "unknown"."""
+
+
+class PatientSex(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """The patient's sex."""
+
+    FEMALE = "female"
+    MALE = "male"
+    UNSPECIFIED = "unspecified"
+
+
+class RadiologyInsightsInferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """A Radiology Insights inference types."""
+
+    AGE_MISMATCH = "ageMismatch"
+    """Age mismatch inference type"""
+    LATERALITY_DISCREPANCY = "lateralityDiscrepancy"
+    """Laterality discrepancy inference type"""
+    SEX_MISMATCH = "sexMismatch"
+    """Sex mismatch inference type"""
+    COMPLETE_ORDER_DISCREPANCY = "completeOrderDiscrepancy"
+    """Complete order discrepancy inference type"""
+    LIMITED_ORDER_DISCREPANCY = "limitedOrderDiscrepancy"
+    """Limited order discrepancy inference type"""
+    FINDING = "finding"
+    """Finding inference type"""
+    CRITICAL_RESULT = "criticalResult"
+    """Critical finding inference type"""
+    FOLLOWUP_RECOMMENDATION = "followupRecommendation"
+    """Recommendation inference type"""
+    FOLLOWUP_COMMUNICATION = "followupCommunication"
+    """Followup Communication inference type"""
+    RADIOLOGY_PROCEDURE = "radiologyProcedure"
+    """Radiology Procedure inference type"""
+
+
+class RecommendationFindingStatusType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Recommendation finding status."""
+
+    PRESENT = "present"
+    """Present finding status"""
+    DIFFERENTIAL = "differential"
+    """Differential finding status"""
+    RULE_OUT = "ruleOut"
+    """Rule out finding status"""
+    CONDITIONAL = "conditional"
+    """Conditional finding status"""
+
+
+class ResearchStudyStatusCodeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """https://www.hl7.org/fhir/R4/codesystem-research-study-status.html."""
+
+    ACTIVE = "active"
+    """The study is open for accrual."""
+    ADMINISTRATIVELY_COMPLETED = "administratively-completed"
+    """Study is completed prematurely and will not resume; patients are no longer examined nor
+    treated."""
+    APPROVED = "approved"
+    """Protocol is approved by the review board."""
+    CLOSED_TO_ACCRUAL = "closed-to-accrual"
+    """Study is closed for accrual; patients can be examined and treated."""
+    CLOSED_TO_ACCRUAL_AND_INTERVENTION = "closed-to-accrual-and-intervention"
+    """The study is closed to accrual and intervention, i.e. the study is closed to enrollment, all
+    study subjects have completed treatment or intervention but are still being followed according
+    to the primary objective of the study."""
+    COMPLETED = "completed"
+    """Study is closed to accrual and intervention, i.e. the study is closed to enrollment, all study
+    subjects have completed treatment or intervention but are still being followed according to the
+    primary objective of the study."""
+    DISAPPROVED = "disapproved"
+    """Protocol was disapproved by the review board."""
+    IN_REVIEW = "in-review"
+    """Protocol is submitted to the review board for approval."""
+    TEMPORARILY_CLOSED_TO_ACCRUAL = "temporarily-closed-to-accrual"
+    """The study is temporarily closed to accrual; a pause in accrual while study is reviewed, but is
+    expected to resume."""
+    TEMPORARILY_CLOSED_TO_ACCRUAL_AND_INTERVENTION = "temporarily-closed-to-accrual-and-intervention"
+    """Study is temporarily closed for accrual; can be potentially resumed in the future"""
+    WITHDRAWN = "withdrawn"
+    """Protocol was withdrawn by the lead organization."""
+
+
+class SpecialtyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Known values codes that can be used to indicate the type of the Specialty."""
+
+    PATHOLOGY = "pathology"
+    """pathology"""
+    RADIOLOGY = "radiology"
+    """radiology"""
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_models.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_models.py
new file mode 100644
index 0000000000000..f0273f98b6dcf
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_models.py
@@ -0,0 +1,3586 @@
+# coding=utf-8
+# pylint: disable=too-many-lines
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+import datetime
+from typing import Any, Dict, List, Literal, Mapping, Optional, TYPE_CHECKING, Union, overload
+
+from .. import _model_base
+from .._model_base import rest_discriminator, rest_field
+from ._enums import RadiologyInsightsInferenceType
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from .. import models as _models
+
+
+class RadiologyInsightsInference(_model_base.Model):
+    """An inference made by the Radiology Insights model regarding a patient.
+
+
+    * AgeMismatch
+    * SexMismatch
+    * LateralityDiscrepancy
+    * CompleteOrderDiscrepancy
+    * LimitedOrderDiscrepancy
+    * Finding
+    * CriticalResult
+    * FollowupRecommendation
+    * RadiologyProcedure
+    * FollowupCommunication.
+
+    You probably want to use the sub-classes and not this class directly. Known sub-classes are:
+    AgeMismatchInference, CompleteOrderDiscrepancyInference, CriticalResultInference,
+    FindingInference, FollowupCommunicationInference, FollowupRecommendationInference,
+    LateralityDiscrepancyInference, LimitedOrderDiscrepancyInference, RadiologyProcedureInference,
+    SexMismatchInference
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Required. Known values are: "ageMismatch", "lateralityDiscrepancy", "sexMismatch",
+     "completeOrderDiscrepancy", "limitedOrderDiscrepancy", "finding", "criticalResult",
+     "followupRecommendation", "followupCommunication", and "radiologyProcedure".
+    :vartype kind: str or
+     ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsInferenceType
+    """
+
+    __mapping__: Dict[str, _model_base.Model] = {}
+    extension: Optional[List["_models.Extension"]] = rest_field()
+    """Additional Content defined by implementations."""
+    kind: str = rest_discriminator(name="kind")
+    """Required. Known values are: \"ageMismatch\", \"lateralityDiscrepancy\", \"sexMismatch\",
+     \"completeOrderDiscrepancy\", \"limitedOrderDiscrepancy\", \"finding\", \"criticalResult\",
+     \"followupRecommendation\", \"followupCommunication\", and \"radiologyProcedure\"."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        kind: str,
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class AgeMismatchInference(RadiologyInsightsInference, discriminator="ageMismatch"):
+    """A notification for age mismatch is displayed when the age mentioned in a document for a
+    specific patient does not match the age specified in the patient information.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Age mismatch inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.AGE_MISMATCH
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.AGE_MISMATCH] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Age mismatch inference type"""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.AGE_MISMATCH, **kwargs)
+
+
+class Element(_model_base.Model):
+    """The base definition for all elements contained inside a resource.
+    Based on `FHIR Element <https://www.hl7.org/fhir/R4/element.html>`_.
+
+    :ivar id: Unique id for inter-element referencing.
+    :vartype id: str
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    """
+
+    id: Optional[str] = rest_field()
+    """Unique id for inter-element referencing."""
+    extension: Optional[List["_models.Extension"]] = rest_field()
+    """Additional Content defined by implementations."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Annotation(Element):
+    """A text note which also  contains information about who made the statement and when
+    Based on `FHIR Annotation <https://www.hl7.org/fhir/R4/datatypes.html#Annotation>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: Unique id for inter-element referencing.
+    :vartype id: str
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar author_string: Individual responsible for the annotation.
+    :vartype author_string: str
+    :ivar time: When the annotation was made.
+    :vartype time: str
+    :ivar text: The annotation - text content (as markdown). Required.
+    :vartype text: str
+    """
+
+    author_string: Optional[str] = rest_field(name="authorString")
+    """Individual responsible for the annotation."""
+    time: Optional[str] = rest_field()
+    """When the annotation was made."""
+    text: str = rest_field()
+    """The annotation - text content (as markdown). Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        text: str,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        extension: Optional[List["_models.Extension"]] = None,
+        author_string: Optional[str] = None,
+        time: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class CodeableConcept(Element):
+    """Concept - reference to a terminology or just text
+    Based on `FHIR CodeableConcept <https://www.hl7.org/fhir/R4/datatypes.html#CodeableConcept>`_.
+
+    :ivar coding: Code defined by a terminology system.
+    :vartype coding: list[~azure.healthinsights.radiologyinsights.models.Coding]
+    :ivar text: Plain text representation of the concept.
+    :vartype text: str
+    """
+
+    coding: Optional[List["_models.Coding"]] = rest_field()
+    """Code defined by a terminology system."""
+    text: Optional[str] = rest_field()
+    """Plain text representation of the concept."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        coding: Optional[List["_models.Coding"]] = None,
+        text: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Coding(Element):
+    """A Coding is a representation of a defined concept using a symbol from a defined "code system".
+    Based on `FHIR Coding <https://www.hl7.org/fhir/R4/datatypes.html#Coding>`_.
+
+    :ivar id: Unique id for inter-element referencing.
+    :vartype id: str
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar system: Identity of the terminology system.
+    :vartype system: str
+    :ivar version: Version of the system - if relevant.
+    :vartype version: str
+    :ivar code: Symbol in syntax defined by the system.
+    :vartype code: str
+    :ivar display: Representation defined by the system.
+    :vartype display: str
+    """
+
+    system: Optional[str] = rest_field()
+    """Identity of the terminology system."""
+    version: Optional[str] = rest_field()
+    """Version of the system - if relevant."""
+    code: Optional[str] = rest_field()
+    """Symbol in syntax defined by the system."""
+    display: Optional[str] = rest_field()
+    """Representation defined by the system."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        extension: Optional[List["_models.Extension"]] = None,
+        system: Optional[str] = None,
+        version: Optional[str] = None,
+        code: Optional[str] = None,
+        display: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class CompleteOrderDiscrepancyInference(RadiologyInsightsInference, discriminator="completeOrderDiscrepancy"):
+    """A complete order discrepancy is shown when one or more body parts and/or measurements that
+    should be in the document (because there is a complete order) are not present.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Complete order discrepancy inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.COMPLETE_ORDER_DISCREPANCY
+    :ivar order_type: Order type : CPT ultrasound complete code for abdomen, retroperitoneal,
+     pelvis or breast. Required.
+    :vartype order_type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar missing_body_parts: List of missing body parts required by a complete order : SNOMED CT
+     codes.
+    :vartype missing_body_parts:
+     list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar missing_body_part_measurements: List of missing body parts that require measurement by a
+     complete order : SNOMED CT codes.
+    :vartype missing_body_part_measurements:
+     list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.COMPLETE_ORDER_DISCREPANCY] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Complete order discrepancy inference type"""
+    order_type: "_models.CodeableConcept" = rest_field(name="orderType")
+    """Order type : CPT ultrasound complete code for abdomen, retroperitoneal, pelvis or breast.
+     Required."""
+    missing_body_parts: Optional[List["_models.CodeableConcept"]] = rest_field(name="missingBodyParts")
+    """List of missing body parts required by a complete order : SNOMED CT codes."""
+    missing_body_part_measurements: Optional[List["_models.CodeableConcept"]] = rest_field(
+        name="missingBodyPartMeasurements"
+    )
+    """List of missing body parts that require measurement by a complete order : SNOMED CT codes."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        order_type: "_models.CodeableConcept",
+        extension: Optional[List["_models.Extension"]] = None,
+        missing_body_parts: Optional[List["_models.CodeableConcept"]] = None,
+        missing_body_part_measurements: Optional[List["_models.CodeableConcept"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.COMPLETE_ORDER_DISCREPANCY, **kwargs)
+
+
+class Resource(_model_base.Model):
+    """Resource is the ancestor of DomainResource from which most resources are derived. Bundle,
+    Parameters, and Binary extend Resource directly.
+    Based on [FHIR Resource](https://www.hl7.org/fhir/r4/resource.html.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar resource_type: The type of resource. Required.
+    :vartype resource_type: str
+    :ivar id: Resource Id.
+    :vartype id: str
+    :ivar meta: Metadata about the resource.
+    :vartype meta: ~azure.healthinsights.radiologyinsights.models.Meta
+    :ivar implicit_rules: A set of rules under which this content was created.
+    :vartype implicit_rules: str
+    :ivar language: Language of the resource content.
+    :vartype language: str
+    """
+
+    resource_type: str = rest_field(name="resourceType")
+    """The type of resource. Required."""
+    id: Optional[str] = rest_field()
+    """Resource Id."""
+    meta: Optional["_models.Meta"] = rest_field()
+    """Metadata about the resource."""
+    implicit_rules: Optional[str] = rest_field(name="implicitRules")
+    """A set of rules under which this content was created."""
+    language: Optional[str] = rest_field()
+    """Language of the resource content."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        resource_type: str,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        meta: Optional["_models.Meta"] = None,
+        implicit_rules: Optional[str] = None,
+        language: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class DomainResource(Resource):
+    """A resource with narrative, extensions, and contained resources
+    Based on `FHIR DomainResource <https://www.hl7.org/fhir/domainresource.html>`_.
+
+    You probably want to use the sub-classes and not this class directly. Known sub-classes are:
+    Condition, ResearchStudy
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: Resource Id.
+    :vartype id: str
+    :ivar meta: Metadata about the resource.
+    :vartype meta: ~azure.healthinsights.radiologyinsights.models.Meta
+    :ivar implicit_rules: A set of rules under which this content was created.
+    :vartype implicit_rules: str
+    :ivar language: Language of the resource content.
+    :vartype language: str
+    :ivar text: Text summary of the resource, for human interpretation.
+    :vartype text: ~azure.healthinsights.radiologyinsights.models.Narrative
+    :ivar contained: Contained, inline Resources.
+    :vartype contained: list[~azure.healthinsights.radiologyinsights.models.Resource]
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar modifier_extension: Extensions that cannot be ignored.
+    :vartype modifier_extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar resource_type: Required. Default value is None.
+    :vartype resource_type: str
+    """
+
+    __mapping__: Dict[str, _model_base.Model] = {}
+    text: Optional["_models.Narrative"] = rest_field()
+    """Text summary of the resource, for human interpretation."""
+    contained: Optional[List["_models.Resource"]] = rest_field()
+    """Contained, inline Resources."""
+    extension: Optional[List["_models.Extension"]] = rest_field()
+    """Additional Content defined by implementations."""
+    modifier_extension: Optional[List["_models.Extension"]] = rest_field(name="modifierExtension")
+    """Extensions that cannot be ignored."""
+    resource_type: str = rest_discriminator(name="resourceType")
+    """Required. Default value is None."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        resource_type: str,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        meta: Optional["_models.Meta"] = None,
+        implicit_rules: Optional[str] = None,
+        language: Optional[str] = None,
+        text: Optional["_models.Narrative"] = None,
+        contained: Optional[List["_models.Resource"]] = None,
+        extension: Optional[List["_models.Extension"]] = None,
+        modifier_extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Condition(DomainResource, discriminator="Condition"):  # pylint: disable=too-many-instance-attributes
+    """Detailed information about conditions, problems or diagnoses
+    Based on `FHIR Condition <https://www.hl7.org/fhir/R4/condition.html>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: Resource Id.
+    :vartype id: str
+    :ivar meta: Metadata about the resource.
+    :vartype meta: ~azure.healthinsights.radiologyinsights.models.Meta
+    :ivar implicit_rules: A set of rules under which this content was created.
+    :vartype implicit_rules: str
+    :ivar language: Language of the resource content.
+    :vartype language: str
+    :ivar text: Text summary of the resource, for human interpretation.
+    :vartype text: ~azure.healthinsights.radiologyinsights.models.Narrative
+    :ivar contained: Contained, inline Resources.
+    :vartype contained: list[~azure.healthinsights.radiologyinsights.models.Resource]
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar modifier_extension: Extensions that cannot be ignored.
+    :vartype modifier_extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar resource_type: resourceType. Required. Default value is "Condition".
+    :vartype resource_type: str
+    :ivar identifier: External Ids for this condition.
+    :vartype identifier: list[~azure.healthinsights.radiologyinsights.models.Identifier]
+    :ivar clinical_status: active | recurrence | relapse | inactive | remission | resolved.
+    :vartype clinical_status: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar verification_status: unconfirmed | provisional | differential | confirmed | refuted |
+     entered-in-error.
+    :vartype verification_status: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar category: problem-list-item | encounter-diagnosis.
+    :vartype category: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar severity: Subjective severity of condition.
+    :vartype severity: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar code: Identification of the condition, problem or diagnosis.
+    :vartype code: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar body_site: Anatomical location, if relevant.
+    :vartype body_site: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar encounter: Encounter created as part of.
+    :vartype encounter: ~azure.healthinsights.radiologyinsights.models.Reference
+    :ivar onset_date_time: Estimated or actual date,  date-time, or age.
+    :vartype onset_date_time: str
+    :ivar onset_age: Estimated or actual date,  date-time, or age.
+    :vartype onset_age: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar onset_period: Estimated or actual date,  date-time, or age.
+    :vartype onset_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar onset_range: Estimated or actual date,  date-time, or age.
+    :vartype onset_range: ~azure.healthinsights.radiologyinsights.models.Range
+    :ivar onset_string: Estimated or actual date,  date-time, or age.
+    :vartype onset_string: str
+    :ivar abatement_date_time: When in resolution/remission.
+    :vartype abatement_date_time: str
+    :ivar abatement_age: When in resolution/remission.
+    :vartype abatement_age: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar abatement_period: When in resolution/remission.
+    :vartype abatement_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar abatement_range: When in resolution/remission.
+    :vartype abatement_range: ~azure.healthinsights.radiologyinsights.models.Range
+    :ivar abatement_string: When in resolution/remission.
+    :vartype abatement_string: str
+    :ivar recorded_date: Date record was first recorded.
+    :vartype recorded_date: str
+    :ivar stage: stge/grade, usually assessed formally.
+    :vartype stage: list[~azure.healthinsights.radiologyinsights.models.ConditionStage]
+    :ivar note: Additional information about the Condition.
+    :vartype note: list[~azure.healthinsights.radiologyinsights.models.Annotation]
+    """
+
+    resource_type: Literal["Condition"] = rest_discriminator(name="resourceType")  # type: ignore
+    """resourceType. Required. Default value is \"Condition\"."""
+    identifier: Optional[List["_models.Identifier"]] = rest_field()
+    """External Ids for this condition."""
+    clinical_status: Optional["_models.CodeableConcept"] = rest_field(name="clinicalStatus")
+    """active | recurrence | relapse | inactive | remission | resolved."""
+    verification_status: Optional["_models.CodeableConcept"] = rest_field(name="verificationStatus")
+    """unconfirmed | provisional | differential | confirmed | refuted | entered-in-error."""
+    category: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """problem-list-item | encounter-diagnosis."""
+    severity: Optional["_models.CodeableConcept"] = rest_field()
+    """Subjective severity of condition."""
+    code: Optional["_models.CodeableConcept"] = rest_field()
+    """Identification of the condition, problem or diagnosis."""
+    body_site: Optional[List["_models.CodeableConcept"]] = rest_field(name="bodySite")
+    """Anatomical location, if relevant."""
+    encounter: Optional["_models.Reference"] = rest_field()
+    """Encounter created as part of."""
+    onset_date_time: Optional[str] = rest_field(name="onsetDateTime")
+    """Estimated or actual date,  date-time, or age."""
+    onset_age: Optional["_models.Quantity"] = rest_field(name="onsetAge")
+    """Estimated or actual date,  date-time, or age."""
+    onset_period: Optional["_models.Period"] = rest_field(name="onsetPeriod")
+    """Estimated or actual date,  date-time, or age."""
+    onset_range: Optional["_models.Range"] = rest_field(name="onsetRange")
+    """Estimated or actual date,  date-time, or age."""
+    onset_string: Optional[str] = rest_field(name="onsetString")
+    """Estimated or actual date,  date-time, or age."""
+    abatement_date_time: Optional[str] = rest_field(name="abatementDateTime")
+    """When in resolution/remission."""
+    abatement_age: Optional["_models.Quantity"] = rest_field(name="abatementAge")
+    """When in resolution/remission."""
+    abatement_period: Optional["_models.Period"] = rest_field(name="abatementPeriod")
+    """When in resolution/remission."""
+    abatement_range: Optional["_models.Range"] = rest_field(name="abatementRange")
+    """When in resolution/remission."""
+    abatement_string: Optional[str] = rest_field(name="abatementString")
+    """When in resolution/remission."""
+    recorded_date: Optional[str] = rest_field(name="recordedDate")
+    """Date record was first recorded."""
+    stage: Optional[List["_models.ConditionStage"]] = rest_field()
+    """stge/grade, usually assessed formally."""
+    note: Optional[List["_models.Annotation"]] = rest_field()
+    """Additional information about the Condition."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        meta: Optional["_models.Meta"] = None,
+        implicit_rules: Optional[str] = None,
+        language: Optional[str] = None,
+        text: Optional["_models.Narrative"] = None,
+        contained: Optional[List["_models.Resource"]] = None,
+        extension: Optional[List["_models.Extension"]] = None,
+        modifier_extension: Optional[List["_models.Extension"]] = None,
+        identifier: Optional[List["_models.Identifier"]] = None,
+        clinical_status: Optional["_models.CodeableConcept"] = None,
+        verification_status: Optional["_models.CodeableConcept"] = None,
+        category: Optional[List["_models.CodeableConcept"]] = None,
+        severity: Optional["_models.CodeableConcept"] = None,
+        code: Optional["_models.CodeableConcept"] = None,
+        body_site: Optional[List["_models.CodeableConcept"]] = None,
+        encounter: Optional["_models.Reference"] = None,
+        onset_date_time: Optional[str] = None,
+        onset_age: Optional["_models.Quantity"] = None,
+        onset_period: Optional["_models.Period"] = None,
+        onset_range: Optional["_models.Range"] = None,
+        onset_string: Optional[str] = None,
+        abatement_date_time: Optional[str] = None,
+        abatement_age: Optional["_models.Quantity"] = None,
+        abatement_period: Optional["_models.Period"] = None,
+        abatement_range: Optional["_models.Range"] = None,
+        abatement_string: Optional[str] = None,
+        recorded_date: Optional[str] = None,
+        stage: Optional[List["_models.ConditionStage"]] = None,
+        note: Optional[List["_models.Annotation"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, resource_type="Condition", **kwargs)
+
+
+class ConditionStage(_model_base.Model):
+    """Stage/grade, usually assessed formally
+    Based on `FHIR Condition.Stage <https://www.hl7.org/fhir/R4/condition.html>`_.
+
+    :ivar summary: Simple summary (disease specific).
+    :vartype summary: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar type: Kind of staging.
+    :vartype type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    """
+
+    summary: Optional["_models.CodeableConcept"] = rest_field()
+    """Simple summary (disease specific)."""
+    type: Optional["_models.CodeableConcept"] = rest_field()
+    """Kind of staging."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        summary: Optional["_models.CodeableConcept"] = None,
+        type: Optional["_models.CodeableConcept"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ContactDetail(Element):
+    """Contact details (See: https://www.hl7.org/fhir/R4/metadatatypes.html#ContactDetail).
+
+    :ivar id: Unique id for inter-element referencing.
+    :vartype id: str
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar name: Name of an individual to contact.
+    :vartype name: str
+    :ivar telecom: Contact details for individual or organization.
+    :vartype telecom: list[~azure.healthinsights.radiologyinsights.models.ContactPoint]
+    """
+
+    name: Optional[str] = rest_field()
+    """Name of an individual to contact."""
+    telecom: Optional[List["_models.ContactPoint"]] = rest_field()
+    """Contact details for individual or organization."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        extension: Optional[List["_models.Extension"]] = None,
+        name: Optional[str] = None,
+        telecom: Optional[List["_models.ContactPoint"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ContactPoint(_model_base.Model):
+    """Details for all kinds of technology mediated contact points for a person or organization,
+    including telephone, email, etc.
+    See https://www.hl7.org/fhir/R4/datatypes.html#ContactPoint.
+
+    :ivar system: phone | fax | email | pager | url | sms | other. Known values are: "phone",
+     "fax", "email", "pager", "url", "sms", and "other".
+    :vartype system: str or ~azure.healthinsights.radiologyinsights.models.ContactPointSystem
+    :ivar value: The actual contact point details.
+    :vartype value: str
+    :ivar use: home | work | temp | old | mobile - purpose of this contact point. Known values are:
+     "home", "work", "temp", "old", and "mobile".
+    :vartype use: str or ~azure.healthinsights.radiologyinsights.models.ContactPointUse
+    :ivar rank: Specify preferred order of use (1 = highest).
+    :vartype rank: int
+    :ivar period: Time period when the contact point was/is in use.
+    :vartype period: ~azure.healthinsights.radiologyinsights.models.Period
+    """
+
+    system: Optional[Union[str, "_models.ContactPointSystem"]] = rest_field()
+    """phone | fax | email | pager | url | sms | other. Known values are: \"phone\", \"fax\",
+     \"email\", \"pager\", \"url\", \"sms\", and \"other\"."""
+    value: Optional[str] = rest_field()
+    """The actual contact point details."""
+    use: Optional[Union[str, "_models.ContactPointUse"]] = rest_field()
+    """home | work | temp | old | mobile - purpose of this contact point. Known values are: \"home\",
+     \"work\", \"temp\", \"old\", and \"mobile\"."""
+    rank: Optional[int] = rest_field()
+    """Specify preferred order of use (1 = highest)."""
+    period: Optional["_models.Period"] = rest_field()
+    """Time period when the contact point was/is in use."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        system: Optional[Union[str, "_models.ContactPointSystem"]] = None,
+        value: Optional[str] = None,
+        use: Optional[Union[str, "_models.ContactPointUse"]] = None,
+        rank: Optional[int] = None,
+        period: Optional["_models.Period"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class CriticalResult(_model_base.Model):
+    """Critical Result consists of two properties.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar description: Description : medical problem. Required.
+    :vartype description: str
+    :ivar finding: Finding linked to the critical result.
+    :vartype finding: ~azure.healthinsights.radiologyinsights.models.Observation
+    """
+
+    description: str = rest_field()
+    """Description : medical problem. Required."""
+    finding: Optional["_models.Observation"] = rest_field()
+    """Finding linked to the critical result."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        description: str,
+        finding: Optional["_models.Observation"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class CriticalResultInference(RadiologyInsightsInference, discriminator="criticalResult"):
+    """Critical results refer to findings of utmost importance that may require timely attention due
+    to their potential impact on patient care.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Critical finding inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.CRITICAL_RESULT
+    :ivar result: The complete Critical Result, as outlined below, will be reused for the
+     recommendation. Required.
+    :vartype result: ~azure.healthinsights.radiologyinsights.models.CriticalResult
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.CRITICAL_RESULT] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Critical finding inference type"""
+    result: "_models.CriticalResult" = rest_field()
+    """The complete Critical Result, as outlined below, will be reused for the recommendation.
+     Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        result: "_models.CriticalResult",
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.CRITICAL_RESULT, **kwargs)
+
+
+class DocumentAdministrativeMetadata(_model_base.Model):
+    """Document administrative metadata.
+
+    :ivar ordered_procedures: List of procedure information associated with the document.
+    :vartype ordered_procedures:
+     list[~azure.healthinsights.radiologyinsights.models.OrderedProcedure]
+    :ivar encounter_id: Reference to the encounter associated with the document.
+    :vartype encounter_id: str
+    """
+
+    ordered_procedures: Optional[List["_models.OrderedProcedure"]] = rest_field(name="orderedProcedures")
+    """List of procedure information associated with the document."""
+    encounter_id: Optional[str] = rest_field(name="encounterId")
+    """Reference to the encounter associated with the document."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        ordered_procedures: Optional[List["_models.OrderedProcedure"]] = None,
+        encounter_id: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class DocumentAuthor(_model_base.Model):
+    """Document author.
+
+    :ivar id: author id.
+    :vartype id: str
+    :ivar full_name: Text representation of the full name.
+    :vartype full_name: str
+    """
+
+    id: Optional[str] = rest_field()
+    """author id."""
+    full_name: Optional[str] = rest_field(name="fullName")
+    """Text representation of the full name."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        full_name: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class DocumentContent(_model_base.Model):
+    """The content of the patient document.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar source_type: The type of the content's source.
+     In case the source type is 'inline', the content is given as a string (for instance, text).
+     In case the source type is 'reference', the content is given as a URI. Required. Known values
+     are: "inline" and "reference".
+    :vartype source_type: str or
+     ~azure.healthinsights.radiologyinsights.models.DocumentContentSourceType
+    :ivar value: The content of the document, given either inline (as a string) or as a reference
+     (URI). Required.
+    :vartype value: str
+    """
+
+    source_type: Union[str, "_models.DocumentContentSourceType"] = rest_field(name="sourceType")
+    """The type of the content's source.
+     In case the source type is 'inline', the content is given as a string (for instance, text).
+     In case the source type is 'reference', the content is given as a URI. Required. Known values
+     are: \"inline\" and \"reference\"."""
+    value: str = rest_field()
+    """The content of the document, given either inline (as a string) or as a reference (URI).
+     Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        source_type: Union[str, "_models.DocumentContentSourceType"],
+        value: str,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Error(_model_base.Model):
+    """The error object.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar code: One of a server-defined set of error codes. Required.
+    :vartype code: str
+    :ivar message: A human-readable representation of the error. Required.
+    :vartype message: str
+    :ivar target: The target of the error.
+    :vartype target: str
+    :ivar details: An array of details about specific errors that led to this reported error.
+    :vartype details: list[~azure.healthinsights.radiologyinsights.models.Error]
+    :ivar innererror: An object containing more specific information than the current object about
+     the error.
+    :vartype innererror: ~azure.healthinsights.radiologyinsights.models.InnerError
+    """
+
+    code: str = rest_field()
+    """One of a server-defined set of error codes. Required."""
+    message: str = rest_field()
+    """A human-readable representation of the error. Required."""
+    target: Optional[str] = rest_field()
+    """The target of the error."""
+    details: Optional[List["_models.Error"]] = rest_field()
+    """An array of details about specific errors that led to this reported error."""
+    innererror: Optional["_models.InnerError"] = rest_field()
+    """An object containing more specific information than the current object about the error."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        code: str,
+        message: str,
+        target: Optional[str] = None,
+        details: Optional[List["_models.Error"]] = None,
+        innererror: Optional["_models.InnerError"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Extension(Element):  # pylint: disable=too-many-instance-attributes
+    """Base for all elements
+    Based on `FHIR Element <https://www.hl7.org/fhir/datatypes.html#Element>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar url: Source of the definition for the extension code - a logical name or a URL. Required.
+    :vartype url: str
+    :ivar value_quantity: Value as Quantity.
+    :vartype value_quantity: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar value_codeable_concept: Value as CodeableConcept.
+    :vartype value_codeable_concept: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar value_string: Value as string.
+    :vartype value_string: str
+    :ivar value_boolean: Value as boolean.
+    :vartype value_boolean: bool
+    :ivar value_integer: Value as integer.
+    :vartype value_integer: int
+    :ivar value_range: Value as Range.
+    :vartype value_range: ~azure.healthinsights.radiologyinsights.models.Range
+    :ivar value_ratio: Value as Ratio.
+    :vartype value_ratio: ~azure.healthinsights.radiologyinsights.models.Ratio
+    :ivar value_sampled_data: Value as SampledData.
+    :vartype value_sampled_data: ~azure.healthinsights.radiologyinsights.models.SampledData
+    :ivar value_time: Value as time (hh:mm:ss).
+    :vartype value_time: ~datetime.time
+    :ivar value_date_time: Value as dateTime.
+    :vartype value_date_time: str
+    :ivar value_period: Value as Period.
+    :vartype value_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar value_reference: Value as reference.
+    :vartype value_reference: ~azure.healthinsights.radiologyinsights.models.Reference
+    """
+
+    url: str = rest_field()
+    """Source of the definition for the extension code - a logical name or a URL. Required."""
+    value_quantity: Optional["_models.Quantity"] = rest_field(name="valueQuantity")
+    """Value as Quantity."""
+    value_codeable_concept: Optional["_models.CodeableConcept"] = rest_field(name="valueCodeableConcept")
+    """Value as CodeableConcept."""
+    value_string: Optional[str] = rest_field(name="valueString")
+    """Value as string."""
+    value_boolean: Optional[bool] = rest_field(name="valueBoolean")
+    """Value as boolean."""
+    value_integer: Optional[int] = rest_field(name="valueInteger")
+    """Value as integer."""
+    value_range: Optional["_models.Range"] = rest_field(name="valueRange")
+    """Value as Range."""
+    value_ratio: Optional["_models.Ratio"] = rest_field(name="valueRatio")
+    """Value as Ratio."""
+    value_sampled_data: Optional["_models.SampledData"] = rest_field(name="valueSampledData")
+    """Value as SampledData."""
+    value_time: Optional[datetime.time] = rest_field(name="valueTime")
+    """Value as time (hh:mm:ss)."""
+    value_date_time: Optional[str] = rest_field(name="valueDateTime")
+    """Value as dateTime."""
+    value_period: Optional["_models.Period"] = rest_field(name="valuePeriod")
+    """Value as Period."""
+    value_reference: Optional["_models.Reference"] = rest_field(name="valueReference")
+    """Value as reference."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        url: str,
+        value_quantity: Optional["_models.Quantity"] = None,
+        value_codeable_concept: Optional["_models.CodeableConcept"] = None,
+        value_string: Optional[str] = None,
+        value_boolean: Optional[bool] = None,
+        value_integer: Optional[int] = None,
+        value_range: Optional["_models.Range"] = None,
+        value_ratio: Optional["_models.Ratio"] = None,
+        value_sampled_data: Optional["_models.SampledData"] = None,
+        value_time: Optional[datetime.time] = None,
+        value_date_time: Optional[str] = None,
+        value_period: Optional["_models.Period"] = None,
+        value_reference: Optional["_models.Reference"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class FindingInference(RadiologyInsightsInference, discriminator="finding"):
+    """Findings in a radiology report typically describe abnormalities, lesions, or other notable
+    observations related to the anatomy or pathology of the imaged area.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Finding inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.FINDING
+    :ivar finding: Finding data : contains extensions, fields and components linked with the
+     finding. Required.
+    :vartype finding: ~azure.healthinsights.radiologyinsights.models.Observation
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.FINDING] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Finding inference type"""
+    finding: "_models.Observation" = rest_field()
+    """Finding data : contains extensions, fields and components linked with the finding. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        finding: "_models.Observation",
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.FINDING, **kwargs)
+
+
+class FindingOptions(_model_base.Model):
+    """Finding options.
+
+    :ivar provide_focused_sentence_evidence: If this is true, provide the sentence that contains
+     the first token of the finding's clinical indicator (i.e. the medical problem), if there is
+     one. This sentence is provided as an extension with url 'ci_sentence', next to the token
+     evidence. Default is false.
+    :vartype provide_focused_sentence_evidence: bool
+    """
+
+    provide_focused_sentence_evidence: Optional[bool] = rest_field(name="provideFocusedSentenceEvidence")
+    """If this is true, provide the sentence that contains the first token of the finding's clinical
+     indicator (i.e. the medical problem), if there is one. This sentence is provided as an
+     extension with url 'ci_sentence', next to the token evidence. Default is false."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        provide_focused_sentence_evidence: Optional[bool] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class FollowupCommunicationInference(RadiologyInsightsInference, discriminator="followupCommunication"):
+    """Follow-up communication involves the exchange of important information, recommendations, or
+    updates between radiologists and other healthcare professionals involved in a patient's care.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Followup Communication inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.FOLLOWUP_COMMUNICATION
+    :ivar communicated_at: Communication date and time.
+    :vartype communicated_at: list[~datetime.datetime]
+    :ivar recipient: Recipient of the communication.
+    :vartype recipient: list[str or
+     ~azure.healthinsights.radiologyinsights.models.MedicalProfessionalType]
+    :ivar was_acknowledged: Communication was acknowledged. Required.
+    :vartype was_acknowledged: bool
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.FOLLOWUP_COMMUNICATION] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Followup Communication inference type"""
+    communicated_at: Optional[List[datetime.datetime]] = rest_field(name="communicatedAt", format="rfc3339")
+    """Communication date and time."""
+    recipient: Optional[List[Union[str, "_models.MedicalProfessionalType"]]] = rest_field()
+    """Recipient of the communication."""
+    was_acknowledged: bool = rest_field(name="wasAcknowledged")
+    """Communication was acknowledged. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        was_acknowledged: bool,
+        extension: Optional[List["_models.Extension"]] = None,
+        communicated_at: Optional[List[datetime.datetime]] = None,
+        recipient: Optional[List[Union[str, "_models.MedicalProfessionalType"]]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.FOLLOWUP_COMMUNICATION, **kwargs)
+
+
+class FollowupRecommendationInference(RadiologyInsightsInference, discriminator="followupRecommendation"):
+    """Follow-up recommendations offer guidance to healthcare providers on managing and monitoring
+    patients based on the findings of imaging studies.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Recommendation inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.FOLLOWUP_RECOMMENDATION
+    :ivar effective_at: Date and time are displayed when the procedure is recommended to be done at
+     a specific point in time.
+    :vartype effective_at: str
+    :ivar effective_period: The period is shown if a specific period is mentioned, with a start and
+     end date-time.
+    :vartype effective_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar findings: Findings related to the recommendation.
+    :vartype findings: list[~azure.healthinsights.radiologyinsights.models.RecommendationFinding]
+    :ivar is_conditional: The conditional value indicates whether or not the sentence containing
+     the recommendation includes a conditional statement. Keywords for conditional statements
+     include 'if', 'when', 'unless', and so on. Required.
+    :vartype is_conditional: bool
+    :ivar is_option: The option value indicates whether or not the sentence containing the
+     recommendation includes an optional statement. Keywords for optional statements include
+     'recommend', 'consider', and so on. Required.
+    :vartype is_option: bool
+    :ivar is_guideline: The guideline value indicates whether or not the recommendation is part of
+     a guideline section that compiles all recommendations applicable to various findings. Required.
+    :vartype is_guideline: bool
+    :ivar is_hedging: Hedging refers to ambiguous, vague or imprecise language within the sentence
+     of the recommendation. Keywords for hedging are 'can be','may be',and so on. Required.
+    :vartype is_hedging: bool
+    :ivar recommended_procedure: The procedure recommendation can be a generic procedure or an
+     imaging procedure. Required.
+    :vartype recommended_procedure:
+     ~azure.healthinsights.radiologyinsights.models.ProcedureRecommendation
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.FOLLOWUP_RECOMMENDATION] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Recommendation inference type"""
+    effective_at: Optional[str] = rest_field(name="effectiveAt")
+    """Date and time are displayed when the procedure is recommended to be done at a specific point in
+     time."""
+    effective_period: Optional["_models.Period"] = rest_field(name="effectivePeriod")
+    """The period is shown if a specific period is mentioned, with a start and end date-time."""
+    findings: Optional[List["_models.RecommendationFinding"]] = rest_field()
+    """Findings related to the recommendation."""
+    is_conditional: bool = rest_field(name="isConditional")
+    """The conditional value indicates whether or not the sentence containing the recommendation
+     includes a conditional statement. Keywords for conditional statements include 'if', 'when',
+     'unless', and so on. Required."""
+    is_option: bool = rest_field(name="isOption")
+    """The option value indicates whether or not the sentence containing the recommendation includes
+     an optional statement. Keywords for optional statements include 'recommend', 'consider', and so
+     on. Required."""
+    is_guideline: bool = rest_field(name="isGuideline")
+    """The guideline value indicates whether or not the recommendation is part of a guideline section
+     that compiles all recommendations applicable to various findings. Required."""
+    is_hedging: bool = rest_field(name="isHedging")
+    """Hedging refers to ambiguous, vague or imprecise language within the sentence of the
+     recommendation. Keywords for hedging are 'can be','may be',and so on. Required."""
+    recommended_procedure: "_models.ProcedureRecommendation" = rest_field(name="recommendedProcedure")
+    """The procedure recommendation can be a generic procedure or an imaging procedure. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        is_conditional: bool,
+        is_option: bool,
+        is_guideline: bool,
+        is_hedging: bool,
+        recommended_procedure: "_models.ProcedureRecommendation",
+        extension: Optional[List["_models.Extension"]] = None,
+        effective_at: Optional[str] = None,
+        effective_period: Optional["_models.Period"] = None,
+        findings: Optional[List["_models.RecommendationFinding"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.FOLLOWUP_RECOMMENDATION, **kwargs)
+
+
+class FollowupRecommendationOptions(_model_base.Model):
+    """Follow-up recommendation options.
+
+    :ivar include_recommendations_with_no_specified_modality: Include/Exclude follow-up
+     recommendations without a specific radiology procedure. Default is false.
+    :vartype include_recommendations_with_no_specified_modality: bool
+    :ivar include_recommendations_in_references: Include/Exclude follow-up recommendations in
+     references to a guideline or article. Default is false.
+    :vartype include_recommendations_in_references: bool
+    :ivar provide_focused_sentence_evidence: If this is true, provide one or more sentences as
+     evidence for the recommendation, next to the token evidence. The start and end positions of
+     these sentences will be put in an extension with url 'modality_sentences'. Default is false.
+    :vartype provide_focused_sentence_evidence: bool
+    """
+
+    include_recommendations_with_no_specified_modality: Optional[bool] = rest_field(
+        name="includeRecommendationsWithNoSpecifiedModality"
+    )
+    """Include/Exclude follow-up recommendations without a specific radiology procedure. Default is
+     false."""
+    include_recommendations_in_references: Optional[bool] = rest_field(name="includeRecommendationsInReferences")
+    """Include/Exclude follow-up recommendations in references to a guideline or article. Default is
+     false."""
+    provide_focused_sentence_evidence: Optional[bool] = rest_field(name="provideFocusedSentenceEvidence")
+    """If this is true, provide one or more sentences as evidence for the recommendation, next to the
+     token evidence. The start and end positions of these sentences will be put in an extension with
+     url 'modality_sentences'. Default is false."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        include_recommendations_with_no_specified_modality: Optional[bool] = None,
+        include_recommendations_in_references: Optional[bool] = None,
+        provide_focused_sentence_evidence: Optional[bool] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ProcedureRecommendation(_model_base.Model):
+    """The procedure recommendation can be a generic procedure or an imaging procedure.
+
+    You probably want to use the sub-classes and not this class directly. Known sub-classes are:
+    GenericProcedureRecommendation, ImagingProcedureRecommendation
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Required. Default value is None.
+    :vartype kind: str
+    """
+
+    __mapping__: Dict[str, _model_base.Model] = {}
+    extension: Optional[List["_models.Extension"]] = rest_field()
+    """Additional Content defined by implementations."""
+    kind: str = rest_discriminator(name="kind")
+    """Required. Default value is None."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        kind: str,
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class GenericProcedureRecommendation(ProcedureRecommendation, discriminator="genericProcedureRecommendation"):
+    """Generic procedure information.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Procedure type : generic. Required. Default value is
+     "genericProcedureRecommendation".
+    :vartype kind: str
+    :ivar code: Procedure modality : SNOMED CT code. Required.
+    :vartype code: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar description: Procedure description : MANAGEMENT PROCEDURE (PROCEDURE) or CONSULTATION
+     (PROCEDURE) based on SNOMED CT.
+    :vartype description: str
+    """
+
+    kind: Literal["genericProcedureRecommendation"] = rest_discriminator(name="kind")  # type: ignore
+    """Procedure type : generic. Required. Default value is \"genericProcedureRecommendation\"."""
+    code: "_models.CodeableConcept" = rest_field()
+    """Procedure modality : SNOMED CT code. Required."""
+    description: Optional[str] = rest_field()
+    """Procedure description : MANAGEMENT PROCEDURE (PROCEDURE) or CONSULTATION (PROCEDURE) based on
+     SNOMED CT."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        code: "_models.CodeableConcept",
+        extension: Optional[List["_models.Extension"]] = None,
+        description: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind="genericProcedureRecommendation", **kwargs)
+
+
+class HealthInsightsErrorResponse(_model_base.Model):
+    """A response containing error details.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar error: The error object. Required.
+    :vartype error: ~azure.healthinsights.radiologyinsights.models.Error
+    :ivar request_id: An opaque, globally-unique, server-generated string identifier for the
+     request. Required.
+    :vartype request_id:
+     ~azure.healthinsights.radiologyinsights.models.HealthInsightsErrorResponseRequestId
+    """
+
+    error: "_models.Error" = rest_field()
+    """The error object. Required."""
+    request_id: "_models.HealthInsightsErrorResponseRequestId" = rest_field(name="requestId")
+    """An opaque, globally-unique, server-generated string identifier for the request. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        error: "_models.Error",
+        request_id: "_models.HealthInsightsErrorResponseRequestId",
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class HealthInsightsErrorResponseRequestId(_model_base.Model):
+    """HealthInsightsErrorResponseRequestId.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar response: Required.
+    :vartype response: ~azure.healthinsights.radiologyinsights.models.RequestIdResponseHeader
+    """
+
+    response: "_models.RequestIdResponseHeader" = rest_field()
+    """Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        response: "_models.RequestIdResponseHeader",
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Identifier(Element):
+    """An identifier intended for computation
+    Based on `FHIR Identifier <https://www.hl7.org/fhir/R4/identifier.html>`_.
+
+    :ivar use: usual | official | temp | secondary | old (If known).
+    :vartype use: str
+    :ivar type: Description of identifier.
+    :vartype type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar system: The namespace for the identifier value.
+    :vartype system: str
+    :ivar value: The value that is unique.
+    :vartype value: str
+    :ivar period: Time period when id is/was valid for use.
+    :vartype period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar assigner: Organization that issued id (may be just text).
+    :vartype assigner: ~azure.healthinsights.radiologyinsights.models.Reference
+    """
+
+    use: Optional[str] = rest_field()
+    """usual | official | temp | secondary | old (If known)."""
+    type: Optional["_models.CodeableConcept"] = rest_field()
+    """Description of identifier."""
+    system: Optional[str] = rest_field()
+    """The namespace for the identifier value."""
+    value: Optional[str] = rest_field()
+    """The value that is unique."""
+    period: Optional["_models.Period"] = rest_field()
+    """Time period when id is/was valid for use."""
+    assigner: Optional["_models.Reference"] = rest_field()
+    """Organization that issued id (may be just text)."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        use: Optional[str] = None,
+        type: Optional["_models.CodeableConcept"] = None,
+        system: Optional[str] = None,
+        value: Optional[str] = None,
+        period: Optional["_models.Period"] = None,
+        assigner: Optional["_models.Reference"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ImagingProcedure(_model_base.Model):
+    """Imaging procedure.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar modality: Modality : SNOMED CT code. Required.
+    :vartype modality: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar anatomy: Anatomy : SNOMED CT code. Required.
+    :vartype anatomy: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar laterality: Laterality : SNOMED CT code.
+    :vartype laterality: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar contrast: Contrast : see RadiologyCodeWithTypes (below).
+    :vartype contrast: ~azure.healthinsights.radiologyinsights.models.RadiologyCodeWithTypes
+    :ivar view: View : see RadiologyCodeWithTypes (below).
+    :vartype view: ~azure.healthinsights.radiologyinsights.models.RadiologyCodeWithTypes
+    """
+
+    modality: "_models.CodeableConcept" = rest_field()
+    """Modality : SNOMED CT code. Required."""
+    anatomy: "_models.CodeableConcept" = rest_field()
+    """Anatomy : SNOMED CT code. Required."""
+    laterality: Optional["_models.CodeableConcept"] = rest_field()
+    """Laterality : SNOMED CT code."""
+    contrast: Optional["_models.RadiologyCodeWithTypes"] = rest_field()
+    """Contrast : see RadiologyCodeWithTypes (below)."""
+    view: Optional["_models.RadiologyCodeWithTypes"] = rest_field()
+    """View : see RadiologyCodeWithTypes (below)."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        modality: "_models.CodeableConcept",
+        anatomy: "_models.CodeableConcept",
+        laterality: Optional["_models.CodeableConcept"] = None,
+        contrast: Optional["_models.RadiologyCodeWithTypes"] = None,
+        view: Optional["_models.RadiologyCodeWithTypes"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ImagingProcedureRecommendation(ProcedureRecommendation, discriminator="imagingProcedureRecommendation"):
+    """Imaging procedures.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Procedure type : imaging. Required. Default value is
+     "imagingProcedureRecommendation".
+    :vartype kind: str
+    :ivar procedure_codes: LOINC codes for the procedure.
+    :vartype procedure_codes: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar imaging_procedures: Imaging procedures. Required.
+    :vartype imaging_procedures:
+     list[~azure.healthinsights.radiologyinsights.models.ImagingProcedure]
+    """
+
+    kind: Literal["imagingProcedureRecommendation"] = rest_discriminator(name="kind")  # type: ignore
+    """Procedure type : imaging. Required. Default value is \"imagingProcedureRecommendation\"."""
+    procedure_codes: Optional[List["_models.CodeableConcept"]] = rest_field(name="procedureCodes")
+    """LOINC codes for the procedure."""
+    imaging_procedures: List["_models.ImagingProcedure"] = rest_field(name="imagingProcedures")
+    """Imaging procedures. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        imaging_procedures: List["_models.ImagingProcedure"],
+        extension: Optional[List["_models.Extension"]] = None,
+        procedure_codes: Optional[List["_models.CodeableConcept"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind="imagingProcedureRecommendation", **kwargs)
+
+
+class InnerError(_model_base.Model):
+    """An object containing more specific information about the error. As per Microsoft One API
+    guidelines -
+    https://github.com/Microsoft/api-guidelines/blob/vNext/Guidelines.md#7102-error-condition-responses.
+
+    :ivar code: One of a server-defined set of error codes.
+    :vartype code: str
+    :ivar innererror: Inner error.
+    :vartype innererror: ~azure.healthinsights.radiologyinsights.models.InnerError
+    """
+
+    code: Optional[str] = rest_field()
+    """One of a server-defined set of error codes."""
+    innererror: Optional["_models.InnerError"] = rest_field()
+    """Inner error."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        code: Optional[str] = None,
+        innererror: Optional["_models.InnerError"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class LateralityDiscrepancyInference(RadiologyInsightsInference, discriminator="lateralityDiscrepancy"):
+    """A laterality mismatch occurs when there is a discrepancy between the clinical documentation and
+    the ordered procedure (orderLateralityMismatch), a contradiction within the clinical document
+    (textLateralityContradiction), or when no laterality is mentioned (textLateralityMissing).
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Laterality discrepancy inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.LATERALITY_DISCREPANCY
+    :ivar laterality_indication: Laterality indication : SNOMED CT code for laterality qualifier
+     value.
+    :vartype laterality_indication: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar discrepancy_type: Mismatch type : orderLateralityMismatch, textLateralityContradiction,
+     textLateralityMissing. Required. Known values are: "orderLateralityMismatch",
+     "textLateralityContradiction", and "textLateralityMissing".
+    :vartype discrepancy_type: str or
+     ~azure.healthinsights.radiologyinsights.models.LateralityDiscrepancyType
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.LATERALITY_DISCREPANCY] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Laterality discrepancy inference type"""
+    laterality_indication: Optional["_models.CodeableConcept"] = rest_field(name="lateralityIndication")
+    """Laterality indication : SNOMED CT code for laterality qualifier value."""
+    discrepancy_type: Union[str, "_models.LateralityDiscrepancyType"] = rest_field(name="discrepancyType")
+    """Mismatch type : orderLateralityMismatch, textLateralityContradiction, textLateralityMissing.
+     Required. Known values are: \"orderLateralityMismatch\", \"textLateralityContradiction\", and
+     \"textLateralityMissing\"."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        discrepancy_type: Union[str, "_models.LateralityDiscrepancyType"],
+        extension: Optional[List["_models.Extension"]] = None,
+        laterality_indication: Optional["_models.CodeableConcept"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.LATERALITY_DISCREPANCY, **kwargs)
+
+
+class LimitedOrderDiscrepancyInference(RadiologyInsightsInference, discriminator="limitedOrderDiscrepancy"):
+    """A limited order discrepancy occurs when there is a limited order, but all body parts and
+    measurements that are needed for a complete order are present in the document.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Limited order discrepancy inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.LIMITED_ORDER_DISCREPANCY
+    :ivar order_type: Order type : CPT ultrasound complete code for abdomen, retroperitoneal,
+     pelvis or breast. Required.
+    :vartype order_type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar present_body_parts: List of body parts found in the document : SNOMED CT codes.
+    :vartype present_body_parts:
+     list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar present_body_part_measurements: List of body parts that are measured according to the
+     document : SNOMED CT codes.
+    :vartype present_body_part_measurements:
+     list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.LIMITED_ORDER_DISCREPANCY] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Limited order discrepancy inference type"""
+    order_type: "_models.CodeableConcept" = rest_field(name="orderType")
+    """Order type : CPT ultrasound complete code for abdomen, retroperitoneal, pelvis or breast.
+     Required."""
+    present_body_parts: Optional[List["_models.CodeableConcept"]] = rest_field(name="presentBodyParts")
+    """List of body parts found in the document : SNOMED CT codes."""
+    present_body_part_measurements: Optional[List["_models.CodeableConcept"]] = rest_field(
+        name="presentBodyPartMeasurements"
+    )
+    """List of body parts that are measured according to the document : SNOMED CT codes."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        order_type: "_models.CodeableConcept",
+        extension: Optional[List["_models.Extension"]] = None,
+        present_body_parts: Optional[List["_models.CodeableConcept"]] = None,
+        present_body_part_measurements: Optional[List["_models.CodeableConcept"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.LIMITED_ORDER_DISCREPANCY, **kwargs)
+
+
+class Meta(_model_base.Model):
+    """Metadata about a resource
+    Based on `FHIR Meta <https://www.hl7.org/fhir/R4/resource.html#Meta>`_.
+
+    :ivar version_id: The version specific identifier, as it appears in the version portion of the
+     URL. This value changes when the resource is created, updated, or deleted.
+    :vartype version_id: str
+    :ivar last_updated: When the resource last changed - e.g. when the version changed.
+    :vartype last_updated: str
+    :ivar source: A uri that identifies the source system of the resource. This provides a minimal
+     amount of Provenance information that can be used to track or differentiate the source of
+     information in the resource. The source may identify another FHIR server, document, message,
+     database, etc.
+    :vartype source: str
+    :ivar profile: A list of profiles (references to `StructureDefinition
+     <https://www.hl7.org/fhir/structuredefinition.html>`_ resources) that this resource claims to
+     conform to. The URL is a reference to `StructureDefinition.url
+     <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_.
+    :vartype profile: list[str]
+    :ivar security: Security labels applied to this resource. These tags connect specific resources
+     to the overall security policy and infrastructure.
+    :vartype security: list[~azure.healthinsights.radiologyinsights.models.Coding]
+    :ivar tag: Tags applied to this resource. Tags are intended to be used to identify and relate
+     resources to process and workflow, and applications are not required to consider the tags when
+     interpreting the meaning of a resource.
+    :vartype tag: list[~azure.healthinsights.radiologyinsights.models.Coding]
+    """
+
+    version_id: Optional[str] = rest_field(name="versionId")
+    """The version specific identifier, as it appears in the version portion of the URL. This value
+     changes when the resource is created, updated, or deleted."""
+    last_updated: Optional[str] = rest_field(name="lastUpdated")
+    """When the resource last changed - e.g. when the version changed."""
+    source: Optional[str] = rest_field()
+    """A uri that identifies the source system of the resource. This provides a minimal amount of
+     Provenance information that can be used to track or differentiate the source of information in
+     the resource. The source may identify another FHIR server, document, message, database, etc."""
+    profile: Optional[List[str]] = rest_field()
+    """A list of profiles (references to `StructureDefinition
+     <https://www.hl7.org/fhir/structuredefinition.html>`_ resources) that this resource claims to
+     conform to. The URL is a reference to `StructureDefinition.url
+     <https://www.hl7.org/fhir/structuredefinition-definitions.html#StructureDefinition.url>`_."""
+    security: Optional[List["_models.Coding"]] = rest_field()
+    """Security labels applied to this resource. These tags connect specific resources to the overall
+     security policy and infrastructure."""
+    tag: Optional[List["_models.Coding"]] = rest_field()
+    """Tags applied to this resource. Tags are intended to be used to identify and relate resources to
+     process and workflow, and applications are not required to consider the tags when interpreting
+     the meaning of a resource."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        version_id: Optional[str] = None,
+        last_updated: Optional[str] = None,
+        source: Optional[str] = None,
+        profile: Optional[List[str]] = None,
+        security: Optional[List["_models.Coding"]] = None,
+        tag: Optional[List["_models.Coding"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Narrative(Element):
+    """Any resource that is a `DomainResource <https://www.hl7.org/fhir/domainresource.html>`_ may
+    include a human-readable narrative that contains a summary of the resource and may be used to
+    represent the content of the resource to a human.
+    Based on `FHIR Narrative <https://www.hl7.org/fhir/R4/narrative.html#Narrative>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: Unique id for inter-element referencing.
+    :vartype id: str
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar status: generated, extensions, additional, empty. Required.
+    :vartype status: str
+    :ivar div: xhtml. Required.
+    :vartype div: str
+    """
+
+    status: str = rest_field()
+    """generated, extensions, additional, empty. Required."""
+    div: str = rest_field()
+    """xhtml. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: str,
+        div: str,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Observation(DomainResource):  # pylint: disable=too-many-instance-attributes
+    """Detailed information about observations
+    Based on `FHIR Observation <https://www.hl7.org/fhir/R4/observation.html>`_.
+
+    Readonly 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 server.
+
+    :ivar id: Resource Id.
+    :vartype id: str
+    :ivar meta: Metadata about the resource.
+    :vartype meta: ~azure.healthinsights.radiologyinsights.models.Meta
+    :ivar implicit_rules: A set of rules under which this content was created.
+    :vartype implicit_rules: str
+    :ivar language: Language of the resource content.
+    :vartype language: str
+    :ivar text: Text summary of the resource, for human interpretation.
+    :vartype text: ~azure.healthinsights.radiologyinsights.models.Narrative
+    :ivar contained: Contained, inline Resources.
+    :vartype contained: list[~azure.healthinsights.radiologyinsights.models.Resource]
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar modifier_extension: Extensions that cannot be ignored.
+    :vartype modifier_extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar resource_type: resourceType. Required. Default value is "Observation".
+    :vartype resource_type: str
+    :ivar identifier: Business Identifier for observation.
+    :vartype identifier: list[~azure.healthinsights.radiologyinsights.models.Identifier]
+    :ivar status: registered | preliminary | final | amended +. Required. Known values are:
+     "registered", "preliminary", "final", "amended", "corrected", "cancelled", "entered-in-error",
+     and "unknown".
+    :vartype status: str or
+     ~azure.healthinsights.radiologyinsights.models.ObservationStatusCodeType
+    :ivar category: Classification of  type of observation.
+    :vartype category: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar code: Type of observation (code / type). Required.
+    :vartype code: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar subject: Who and/or what the observation is about.
+    :vartype subject: ~azure.healthinsights.radiologyinsights.models.Reference
+    :ivar encounter: Healthcare event during which this observation is made.
+    :vartype encounter: ~azure.healthinsights.radiologyinsights.models.Reference
+    :ivar effective_date_time: Clinically relevant time/time-period for observation.
+    :vartype effective_date_time: str
+    :ivar effective_period: Clinically relevant time/time-period for observation.
+    :vartype effective_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar effective_instant: Clinically relevant time/time-period for observation.
+    :vartype effective_instant: str
+    :ivar issued: Date/Time this version was made available.
+    :vartype issued: str
+    :ivar value_quantity: Actual result.
+    :vartype value_quantity: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar value_codeable_concept: Actual result.
+    :vartype value_codeable_concept: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar value_string: Actual result.
+    :vartype value_string: str
+    :ivar value_boolean: Actual result.
+    :vartype value_boolean: bool
+    :ivar value_integer: Actual result.
+    :vartype value_integer: int
+    :ivar value_range: Actual result.
+    :vartype value_range: ~azure.healthinsights.radiologyinsights.models.Range
+    :ivar value_ratio: Actual result.
+    :vartype value_ratio: ~azure.healthinsights.radiologyinsights.models.Ratio
+    :ivar value_sampled_data: Actual result.
+    :vartype value_sampled_data: ~azure.healthinsights.radiologyinsights.models.SampledData
+    :ivar value_time: Actual result.
+    :vartype value_time: ~datetime.time
+    :ivar value_date_time: Actual result.
+    :vartype value_date_time: str
+    :ivar value_period: Actual result.
+    :vartype value_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar data_absent_reason: Why the result is missing.
+    :vartype data_absent_reason: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar interpretation: High, low, normal, etc.
+    :vartype interpretation: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar note: Comments about the observation.
+    :vartype note: list[~azure.healthinsights.radiologyinsights.models.Annotation]
+    :ivar body_site: Observed body part.
+    :vartype body_site: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar method: How it was done.
+    :vartype method: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar reference_range: Provides guide for interpretation.
+    :vartype reference_range:
+     list[~azure.healthinsights.radiologyinsights.models.ObservationReferenceRange]
+    :ivar has_member: Related resource that belongs to the Observation group.
+    :vartype has_member: list[~azure.healthinsights.radiologyinsights.models.Reference]
+    :ivar derived_from: Related measurements the observation is made from.
+    :vartype derived_from: list[~azure.healthinsights.radiologyinsights.models.Reference]
+    :ivar component: Component results.
+    :vartype component: list[~azure.healthinsights.radiologyinsights.models.ObservationComponent]
+    """
+
+    resource_type: Literal["Observation"] = rest_field(name="resourceType")
+    """resourceType. Required. Default value is \"Observation\"."""
+    identifier: Optional[List["_models.Identifier"]] = rest_field()
+    """Business Identifier for observation."""
+    status: Union[str, "_models.ObservationStatusCodeType"] = rest_field()
+    """registered | preliminary | final | amended +. Required. Known values are: \"registered\",
+     \"preliminary\", \"final\", \"amended\", \"corrected\", \"cancelled\", \"entered-in-error\",
+     and \"unknown\"."""
+    category: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """Classification of  type of observation."""
+    code: "_models.CodeableConcept" = rest_field()
+    """Type of observation (code / type). Required."""
+    subject: Optional["_models.Reference"] = rest_field()
+    """Who and/or what the observation is about."""
+    encounter: Optional["_models.Reference"] = rest_field()
+    """Healthcare event during which this observation is made."""
+    effective_date_time: Optional[str] = rest_field(name="effectiveDateTime")
+    """Clinically relevant time/time-period for observation."""
+    effective_period: Optional["_models.Period"] = rest_field(name="effectivePeriod")
+    """Clinically relevant time/time-period for observation."""
+    effective_instant: Optional[str] = rest_field(name="effectiveInstant")
+    """Clinically relevant time/time-period for observation."""
+    issued: Optional[str] = rest_field()
+    """Date/Time this version was made available."""
+    value_quantity: Optional["_models.Quantity"] = rest_field(name="valueQuantity")
+    """Actual result."""
+    value_codeable_concept: Optional["_models.CodeableConcept"] = rest_field(name="valueCodeableConcept")
+    """Actual result."""
+    value_string: Optional[str] = rest_field(name="valueString")
+    """Actual result."""
+    value_boolean: Optional[bool] = rest_field(name="valueBoolean")
+    """Actual result."""
+    value_integer: Optional[int] = rest_field(name="valueInteger")
+    """Actual result."""
+    value_range: Optional["_models.Range"] = rest_field(name="valueRange")
+    """Actual result."""
+    value_ratio: Optional["_models.Ratio"] = rest_field(name="valueRatio")
+    """Actual result."""
+    value_sampled_data: Optional["_models.SampledData"] = rest_field(name="valueSampledData")
+    """Actual result."""
+    value_time: Optional[datetime.time] = rest_field(name="valueTime")
+    """Actual result."""
+    value_date_time: Optional[str] = rest_field(name="valueDateTime")
+    """Actual result."""
+    value_period: Optional["_models.Period"] = rest_field(name="valuePeriod")
+    """Actual result."""
+    data_absent_reason: Optional["_models.CodeableConcept"] = rest_field(name="dataAbsentReason")
+    """Why the result is missing."""
+    interpretation: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """High, low, normal, etc."""
+    note: Optional[List["_models.Annotation"]] = rest_field()
+    """Comments about the observation."""
+    body_site: Optional["_models.CodeableConcept"] = rest_field(name="bodySite")
+    """Observed body part."""
+    method: Optional["_models.CodeableConcept"] = rest_field()
+    """How it was done."""
+    reference_range: Optional[List["_models.ObservationReferenceRange"]] = rest_field(name="referenceRange")
+    """Provides guide for interpretation."""
+    has_member: Optional[List["_models.Reference"]] = rest_field(name="hasMember")
+    """Related resource that belongs to the Observation group."""
+    derived_from: Optional[List["_models.Reference"]] = rest_field(name="derivedFrom")
+    """Related measurements the observation is made from."""
+    component: Optional[List["_models.ObservationComponent"]] = rest_field()
+    """Component results."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Union[str, "_models.ObservationStatusCodeType"],
+        code: "_models.CodeableConcept",
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        meta: Optional["_models.Meta"] = None,
+        implicit_rules: Optional[str] = None,
+        language: Optional[str] = None,
+        text: Optional["_models.Narrative"] = None,
+        contained: Optional[List["_models.Resource"]] = None,
+        extension: Optional[List["_models.Extension"]] = None,
+        modifier_extension: Optional[List["_models.Extension"]] = None,
+        identifier: Optional[List["_models.Identifier"]] = None,
+        category: Optional[List["_models.CodeableConcept"]] = None,
+        subject: Optional["_models.Reference"] = None,
+        encounter: Optional["_models.Reference"] = None,
+        effective_date_time: Optional[str] = None,
+        effective_period: Optional["_models.Period"] = None,
+        effective_instant: Optional[str] = None,
+        issued: Optional[str] = None,
+        value_quantity: Optional["_models.Quantity"] = None,
+        value_codeable_concept: Optional["_models.CodeableConcept"] = None,
+        value_string: Optional[str] = None,
+        value_boolean: Optional[bool] = None,
+        value_integer: Optional[int] = None,
+        value_range: Optional["_models.Range"] = None,
+        value_ratio: Optional["_models.Ratio"] = None,
+        value_sampled_data: Optional["_models.SampledData"] = None,
+        value_time: Optional[datetime.time] = None,
+        value_date_time: Optional[str] = None,
+        value_period: Optional["_models.Period"] = None,
+        data_absent_reason: Optional["_models.CodeableConcept"] = None,
+        interpretation: Optional[List["_models.CodeableConcept"]] = None,
+        note: Optional[List["_models.Annotation"]] = None,
+        body_site: Optional["_models.CodeableConcept"] = None,
+        method: Optional["_models.CodeableConcept"] = None,
+        reference_range: Optional[List["_models.ObservationReferenceRange"]] = None,
+        has_member: Optional[List["_models.Reference"]] = None,
+        derived_from: Optional[List["_models.Reference"]] = None,
+        component: Optional[List["_models.ObservationComponent"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.resource_type: Literal["Observation"] = "Observation"
+
+
+class ObservationComponent(Element):  # pylint: disable=too-many-instance-attributes
+    """Component results
+    Based on `FHIR Observation.component <https://www.hl7.org/fhir/R4/observation.html>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: Unique id for inter-element referencing.
+    :vartype id: str
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar code: Type of component observation (code / type). Required.
+    :vartype code: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar value_quantity: Value as Quantity.
+    :vartype value_quantity: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar value_codeable_concept: Value as CodeableConcept.
+    :vartype value_codeable_concept: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar value_string: Value as string.
+    :vartype value_string: str
+    :ivar value_boolean: Value as boolean.
+    :vartype value_boolean: bool
+    :ivar value_integer: Value as integer.
+    :vartype value_integer: int
+    :ivar value_range: Value as Range.
+    :vartype value_range: ~azure.healthinsights.radiologyinsights.models.Range
+    :ivar value_ratio: Value as Ratio.
+    :vartype value_ratio: ~azure.healthinsights.radiologyinsights.models.Ratio
+    :ivar value_sampled_data: Value as SampledData.
+    :vartype value_sampled_data: ~azure.healthinsights.radiologyinsights.models.SampledData
+    :ivar value_time: Value as time (hh:mm:ss).
+    :vartype value_time: ~datetime.time
+    :ivar value_date_time: Value as dateTime.
+    :vartype value_date_time: str
+    :ivar value_period: Value as Period.
+    :vartype value_period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar value_reference: Value as reference.
+    :vartype value_reference: ~azure.healthinsights.radiologyinsights.models.Reference
+    :ivar data_absent_reason: Why the component result is missing.
+    :vartype data_absent_reason: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar interpretation: High, low, normal, etc.
+    :vartype interpretation: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar reference_range: Provides guide for interpretation of component result.
+    :vartype reference_range:
+     list[~azure.healthinsights.radiologyinsights.models.ObservationReferenceRange]
+    """
+
+    code: "_models.CodeableConcept" = rest_field()
+    """Type of component observation (code / type). Required."""
+    value_quantity: Optional["_models.Quantity"] = rest_field(name="valueQuantity")
+    """Value as Quantity."""
+    value_codeable_concept: Optional["_models.CodeableConcept"] = rest_field(name="valueCodeableConcept")
+    """Value as CodeableConcept."""
+    value_string: Optional[str] = rest_field(name="valueString")
+    """Value as string."""
+    value_boolean: Optional[bool] = rest_field(name="valueBoolean")
+    """Value as boolean."""
+    value_integer: Optional[int] = rest_field(name="valueInteger")
+    """Value as integer."""
+    value_range: Optional["_models.Range"] = rest_field(name="valueRange")
+    """Value as Range."""
+    value_ratio: Optional["_models.Ratio"] = rest_field(name="valueRatio")
+    """Value as Ratio."""
+    value_sampled_data: Optional["_models.SampledData"] = rest_field(name="valueSampledData")
+    """Value as SampledData."""
+    value_time: Optional[datetime.time] = rest_field(name="valueTime")
+    """Value as time (hh:mm:ss)."""
+    value_date_time: Optional[str] = rest_field(name="valueDateTime")
+    """Value as dateTime."""
+    value_period: Optional["_models.Period"] = rest_field(name="valuePeriod")
+    """Value as Period."""
+    value_reference: Optional["_models.Reference"] = rest_field(name="valueReference")
+    """Value as reference."""
+    data_absent_reason: Optional["_models.CodeableConcept"] = rest_field(name="dataAbsentReason")
+    """Why the component result is missing."""
+    interpretation: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """High, low, normal, etc."""
+    reference_range: Optional[List["_models.ObservationReferenceRange"]] = rest_field(name="referenceRange")
+    """Provides guide for interpretation of component result."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        code: "_models.CodeableConcept",
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        extension: Optional[List["_models.Extension"]] = None,
+        value_quantity: Optional["_models.Quantity"] = None,
+        value_codeable_concept: Optional["_models.CodeableConcept"] = None,
+        value_string: Optional[str] = None,
+        value_boolean: Optional[bool] = None,
+        value_integer: Optional[int] = None,
+        value_range: Optional["_models.Range"] = None,
+        value_ratio: Optional["_models.Ratio"] = None,
+        value_sampled_data: Optional["_models.SampledData"] = None,
+        value_time: Optional[datetime.time] = None,
+        value_date_time: Optional[str] = None,
+        value_period: Optional["_models.Period"] = None,
+        value_reference: Optional["_models.Reference"] = None,
+        data_absent_reason: Optional["_models.CodeableConcept"] = None,
+        interpretation: Optional[List["_models.CodeableConcept"]] = None,
+        reference_range: Optional[List["_models.ObservationReferenceRange"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ObservationReferenceRange(_model_base.Model):
+    """Provides guide for interpretation of component result
+    Based on `FHIR Observation.referenceRange <https://www.hl7.org/fhir/R4/observation.html>`_.
+
+    :ivar low: Low Range, if relevant.
+    :vartype low: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar high: High Range, if relevant.
+    :vartype high: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar type: Reference range qualifier.
+    :vartype type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar applies_to: Reference range population.
+    :vartype applies_to: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar age: Applicable age range, if relevant.
+    :vartype age: ~azure.healthinsights.radiologyinsights.models.Range
+    :ivar text: Text based reference range in an observation.
+    :vartype text: str
+    """
+
+    low: Optional["_models.Quantity"] = rest_field()
+    """Low Range, if relevant."""
+    high: Optional["_models.Quantity"] = rest_field()
+    """High Range, if relevant."""
+    type: Optional["_models.CodeableConcept"] = rest_field()
+    """Reference range qualifier."""
+    applies_to: Optional[List["_models.CodeableConcept"]] = rest_field(name="appliesTo")
+    """Reference range population."""
+    age: Optional["_models.Range"] = rest_field()
+    """Applicable age range, if relevant."""
+    text: Optional[str] = rest_field()
+    """Text based reference range in an observation."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        low: Optional["_models.Quantity"] = None,
+        high: Optional["_models.Quantity"] = None,
+        type: Optional["_models.CodeableConcept"] = None,
+        applies_to: Optional[List["_models.CodeableConcept"]] = None,
+        age: Optional["_models.Range"] = None,
+        text: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class OrderedProcedure(_model_base.Model):
+    """Procedure information.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar code: Procedure code.
+    :vartype code: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar description: Procedure description.
+    :vartype description: str
+    """
+
+    extension: Optional[List["_models.Extension"]] = rest_field()
+    """Additional Content defined by implementations."""
+    code: Optional["_models.CodeableConcept"] = rest_field()
+    """Procedure code."""
+    description: Optional[str] = rest_field()
+    """Procedure description."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        extension: Optional[List["_models.Extension"]] = None,
+        code: Optional["_models.CodeableConcept"] = None,
+        description: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class PatientDetails(_model_base.Model):
+    """Patient structured information, including demographics and known structured clinical
+    information.
+
+    :ivar sex: The patient's sex. Known values are: "female", "male", and "unspecified".
+    :vartype sex: str or ~azure.healthinsights.radiologyinsights.models.PatientSex
+    :ivar birth_date: The patient's date of birth.
+    :vartype birth_date: ~datetime.date
+    :ivar clinical_info: Known clinical information for the patient, structured.
+    :vartype clinical_info: list[~azure.healthinsights.radiologyinsights.models.Resource]
+    """
+
+    sex: Optional[Union[str, "_models.PatientSex"]] = rest_field()
+    """The patient's sex. Known values are: \"female\", \"male\", and \"unspecified\"."""
+    birth_date: Optional[datetime.date] = rest_field(name="birthDate")
+    """The patient's date of birth."""
+    clinical_info: Optional[List["_models.Resource"]] = rest_field(name="clinicalInfo")
+    """Known clinical information for the patient, structured."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        sex: Optional[Union[str, "_models.PatientSex"]] = None,
+        birth_date: Optional[datetime.date] = None,
+        clinical_info: Optional[List["_models.Resource"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class PatientDocument(_model_base.Model):
+    """A clinical document related to a patient. Document here is in the wide sense - not just a text
+    document (note).
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar type: The type of the patient document, such as 'note' (text document) or 'fhirBundle'
+     (FHIR JSON document). Required. Known values are: "note", "fhirBundle", "dicom", and
+     "genomicSequencing".
+    :vartype type: str or ~azure.healthinsights.radiologyinsights.models.DocumentType
+    :ivar clinical_type: The type of the clinical document. Known values are: "consultation",
+     "dischargeSummary", "historyAndPhysical", "radiologyReport", "procedure", "progress",
+     "laboratory", and "pathologyReport".
+    :vartype clinical_type: str or
+     ~azure.healthinsights.radiologyinsights.models.ClinicalDocumentType
+    :ivar id: A given identifier for the document. Has to be unique across all documents for a
+     single patient. Required.
+    :vartype id: str
+    :ivar language: A 2 letter ISO 639-1 representation of the language of the document.
+    :vartype language: str
+    :ivar created_at: The date and time when the document was created.
+    :vartype created_at: ~datetime.datetime
+    :ivar authors: Document author(s).
+    :vartype authors: list[~azure.healthinsights.radiologyinsights.models.DocumentAuthor]
+    :ivar specialty_type: specialty type the document. Known values are: "pathology" and
+     "radiology".
+    :vartype specialty_type: str or ~azure.healthinsights.radiologyinsights.models.SpecialtyType
+    :ivar administrative_metadata: Administrative metadata for the document.
+    :vartype administrative_metadata:
+     ~azure.healthinsights.radiologyinsights.models.DocumentAdministrativeMetadata
+    :ivar content: The content of the patient document. Required.
+    :vartype content: ~azure.healthinsights.radiologyinsights.models.DocumentContent
+    """
+
+    type: Union[str, "_models.DocumentType"] = rest_field()
+    """The type of the patient document, such as 'note' (text document) or 'fhirBundle' (FHIR JSON
+     document). Required. Known values are: \"note\", \"fhirBundle\", \"dicom\", and
+     \"genomicSequencing\"."""
+    clinical_type: Optional[Union[str, "_models.ClinicalDocumentType"]] = rest_field(name="clinicalType")
+    """The type of the clinical document. Known values are: \"consultation\", \"dischargeSummary\",
+     \"historyAndPhysical\", \"radiologyReport\", \"procedure\", \"progress\", \"laboratory\", and
+     \"pathologyReport\"."""
+    id: str = rest_field()
+    """A given identifier for the document. Has to be unique across all documents for a single
+     patient. Required."""
+    language: Optional[str] = rest_field()
+    """A 2 letter ISO 639-1 representation of the language of the document."""
+    created_at: Optional[datetime.datetime] = rest_field(name="createdAt", format="rfc3339")
+    """The date and time when the document was created."""
+    authors: Optional[List["_models.DocumentAuthor"]] = rest_field()
+    """Document author(s)."""
+    specialty_type: Optional[Union[str, "_models.SpecialtyType"]] = rest_field(name="specialtyType")
+    """specialty type the document. Known values are: \"pathology\" and \"radiology\"."""
+    administrative_metadata: Optional["_models.DocumentAdministrativeMetadata"] = rest_field(
+        name="administrativeMetadata"
+    )
+    """Administrative metadata for the document."""
+    content: "_models.DocumentContent" = rest_field()
+    """The content of the patient document. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Union[str, "_models.DocumentType"],
+        id: str,  # pylint: disable=redefined-builtin
+        content: "_models.DocumentContent",
+        clinical_type: Optional[Union[str, "_models.ClinicalDocumentType"]] = None,
+        language: Optional[str] = None,
+        created_at: Optional[datetime.datetime] = None,
+        authors: Optional[List["_models.DocumentAuthor"]] = None,
+        specialty_type: Optional[Union[str, "_models.SpecialtyType"]] = None,
+        administrative_metadata: Optional["_models.DocumentAdministrativeMetadata"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class PatientEncounter(_model_base.Model):
+    """visit/encounter information.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: The id of the visit. Required.
+    :vartype id: str
+    :ivar period: Time period of the visit.
+     In case of admission, use timePeriod.start to indicate the admission time and timePeriod.end
+     to indicate the discharge time.
+    :vartype period: ~azure.healthinsights.radiologyinsights.models.TimePeriod
+    :ivar class_property: The class of the encounter. Known values are: "inpatient", "ambulatory",
+     "observation", "emergency", "virtual", and "healthHome".
+    :vartype class_property: str or ~azure.healthinsights.radiologyinsights.models.EncounterClass
+    """
+
+    id: str = rest_field()
+    """The id of the visit. Required."""
+    period: Optional["_models.TimePeriod"] = rest_field()
+    """Time period of the visit.
+     In case of admission, use timePeriod.start to indicate the admission time and timePeriod.end to
+     indicate the discharge time."""
+    class_property: Optional[Union[str, "_models.EncounterClass"]] = rest_field(name="class")
+    """The class of the encounter. Known values are: \"inpatient\", \"ambulatory\", \"observation\",
+     \"emergency\", \"virtual\", and \"healthHome\"."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: str,  # pylint: disable=redefined-builtin
+        period: Optional["_models.TimePeriod"] = None,
+        class_property: Optional[Union[str, "_models.EncounterClass"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class PatientRecord(_model_base.Model):
+    """A patient record, including their clinical information and data.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: A given identifier for the patient. Has to be unique across all patients in a single
+     request. Required.
+    :vartype id: str
+    :ivar details: Patient structured information, including demographics and known structured
+     clinical information.
+    :vartype details: ~azure.healthinsights.radiologyinsights.models.PatientDetails
+    :ivar encounters: Patient encounters/visits.
+    :vartype encounters: list[~azure.healthinsights.radiologyinsights.models.PatientEncounter]
+    :ivar patient_documents: Patient unstructured clinical data, given as documents.
+    :vartype patient_documents:
+     list[~azure.healthinsights.radiologyinsights.models.PatientDocument]
+    """
+
+    id: str = rest_field()
+    """A given identifier for the patient. Has to be unique across all patients in a single request.
+     Required."""
+    details: Optional["_models.PatientDetails"] = rest_field()
+    """Patient structured information, including demographics and known structured clinical
+     information."""
+    encounters: Optional[List["_models.PatientEncounter"]] = rest_field()
+    """Patient encounters/visits."""
+    patient_documents: Optional[List["_models.PatientDocument"]] = rest_field(name="patientDocuments")
+    """Patient unstructured clinical data, given as documents."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        id: str,  # pylint: disable=redefined-builtin
+        details: Optional["_models.PatientDetails"] = None,
+        encounters: Optional[List["_models.PatientEncounter"]] = None,
+        patient_documents: Optional[List["_models.PatientDocument"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Period(Element):
+    """A time period defined by a start and end date and optionally time
+    Based on `FHIR Period <https://www.hl7.org/fhir/R4/datatypes.html#Period>`_.
+
+    :ivar start: Starting time with inclusive boundary.
+    :vartype start: str
+    :ivar end: End time with inclusive boundary, if not ongoing.
+    :vartype end: str
+    """
+
+    start: Optional[str] = rest_field()
+    """Starting time with inclusive boundary."""
+    end: Optional[str] = rest_field()
+    """End time with inclusive boundary, if not ongoing."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Quantity(Element):
+    """A measured or measurable amount
+    Based on `FHIR Quantity <https://www.hl7.org/fhir/R4/datatypes.html#Quantity>`_.
+
+    :ivar value: Numerical value (with implicit precision).
+    :vartype value: float
+    :ivar comparator: < | <= | >= | > - how to understand the value.
+    :vartype comparator: str
+    :ivar unit: Unit representation.
+    :vartype unit: str
+    :ivar system: System that defines coded unit form.
+    :vartype system: str
+    :ivar code: Coded form of the unit.
+    :vartype code: str
+    """
+
+    value: Optional[float] = rest_field()
+    """Numerical value (with implicit precision)."""
+    comparator: Optional[str] = rest_field()
+    """< | <= | >= | > - how to understand the value."""
+    unit: Optional[str] = rest_field()
+    """Unit representation."""
+    system: Optional[str] = rest_field()
+    """System that defines coded unit form."""
+    code: Optional[str] = rest_field()
+    """Coded form of the unit."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        value: Optional[float] = None,
+        comparator: Optional[str] = None,
+        unit: Optional[str] = None,
+        system: Optional[str] = None,
+        code: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyCodeWithTypes(_model_base.Model):
+    """Radiology code with types : used in imaging procedure recommendation for contrast and view.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar code: The SNOMED CT code indicates whether imaging was conducted with or without contrast
+     in the case of contrast, and in the case of views, it denotes the number of views. Required.
+    :vartype code: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar types: The collection of types will indicate the contrast substance used in the case of
+     contrast and, in the case of views, it will specify the types of views, such as lateral and
+     frontal, etc. Required.
+    :vartype types: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    """
+
+    code: "_models.CodeableConcept" = rest_field()
+    """The SNOMED CT code indicates whether imaging was conducted with or without contrast in the case
+     of contrast, and in the case of views, it denotes the number of views. Required."""
+    types: List["_models.CodeableConcept"] = rest_field()
+    """The collection of types will indicate the contrast substance used in the case of contrast and,
+     in the case of views, it will specify the types of views, such as lateral and frontal, etc.
+     Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        code: "_models.CodeableConcept",
+        types: List["_models.CodeableConcept"],
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyInsightsData(_model_base.Model):
+    """Contains the list of patients, and configuration data.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar patients: The list of patients, including their clinical information and data. Required.
+    :vartype patients: list[~azure.healthinsights.radiologyinsights.models.PatientRecord]
+    :ivar configuration: Configuration affecting the Radiology Insights model's inference.
+    :vartype configuration:
+     ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsModelConfiguration
+    """
+
+    patients: List["_models.PatientRecord"] = rest_field()
+    """The list of patients, including their clinical information and data. Required."""
+    configuration: Optional["_models.RadiologyInsightsModelConfiguration"] = rest_field()
+    """Configuration affecting the Radiology Insights model's inference."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        patients: List["_models.PatientRecord"],
+        configuration: Optional["_models.RadiologyInsightsModelConfiguration"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyInsightsInferenceOptions(_model_base.Model):
+    """Options regarding follow up recommendation inferences and finding inferences.
+
+    :ivar followup_recommendation_options: Follow-up recommendation options.
+    :vartype followup_recommendation_options:
+     ~azure.healthinsights.radiologyinsights.models.FollowupRecommendationOptions
+    :ivar finding_options: Finding options.
+    :vartype finding_options: ~azure.healthinsights.radiologyinsights.models.FindingOptions
+    """
+
+    followup_recommendation_options: Optional["_models.FollowupRecommendationOptions"] = rest_field(
+        name="followupRecommendationOptions"
+    )
+    """Follow-up recommendation options."""
+    finding_options: Optional["_models.FindingOptions"] = rest_field(name="findingOptions")
+    """Finding options."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        followup_recommendation_options: Optional["_models.FollowupRecommendationOptions"] = None,
+        finding_options: Optional["_models.FindingOptions"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyInsightsInferenceResult(_model_base.Model):
+    """The inference results for the Radiology Insights request. If field 'status' has value
+    'succeeded', then field 'result' will contain an instance of RadiologyInsightsInferenceResult.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar patient_results: Results for the patients given in the request. Required.
+    :vartype patient_results:
+     list[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsPatientResult]
+    :ivar model_version: The version of the model used for inference, expressed as the model date.
+     Required.
+    :vartype model_version: str
+    """
+
+    patient_results: List["_models.RadiologyInsightsPatientResult"] = rest_field(name="patientResults")
+    """Results for the patients given in the request. Required."""
+    model_version: str = rest_field(name="modelVersion")
+    """The version of the model used for inference, expressed as the model date. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        patient_results: List["_models.RadiologyInsightsPatientResult"],
+        model_version: str,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyInsightsJob(_model_base.Model):
+    """Response for the Radiology Insights request.
+
+    Readonly 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 server.
+
+    :ivar job_data: The request data for the operation.
+    :vartype job_data: ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsData
+    :ivar result: The result of the operation.
+    :vartype result:
+     ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsInferenceResult
+    :ivar status: The status of the job. Required. Known values are: "notStarted", "running",
+     "succeeded", "failed", and "canceled".
+    :vartype status: str or ~azure.healthinsights.radiologyinsights.models.JobStatus
+    :ivar created_at: The date and time when the processing job was created.
+    :vartype created_at: ~datetime.datetime
+    :ivar expires_at: The date and time when the processing job is set to expire.
+    :vartype expires_at: ~datetime.datetime
+    :ivar updated_at: The date and time when the processing job was last updated.
+    :vartype updated_at: ~datetime.datetime
+    :ivar error: Error object that describes the error when status is "Failed".
+    :vartype error: ~azure.healthinsights.radiologyinsights.models.Error
+    """
+
+    job_data: Optional["_models.RadiologyInsightsData"] = rest_field(name="jobData", visibility=["read", "create"])
+    """The request data for the operation."""
+    result: Optional["_models.RadiologyInsightsInferenceResult"] = rest_field(visibility=["read"])
+    """The result of the operation."""
+    status: Union[str, "_models.JobStatus"] = rest_field(visibility=["read"])
+    """The status of the job. Required. Known values are: \"notStarted\", \"running\", \"succeeded\",
+     \"failed\", and \"canceled\"."""
+    created_at: Optional[datetime.datetime] = rest_field(name="createdAt", visibility=["read"], format="rfc3339")
+    """The date and time when the processing job was created."""
+    expires_at: Optional[datetime.datetime] = rest_field(name="expiresAt", visibility=["read"], format="rfc3339")
+    """The date and time when the processing job is set to expire."""
+    updated_at: Optional[datetime.datetime] = rest_field(name="updatedAt", visibility=["read"], format="rfc3339")
+    """The date and time when the processing job was last updated."""
+    error: Optional["_models.Error"] = rest_field(visibility=["read"])
+    """Error object that describes the error when status is \"Failed\"."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        job_data: Optional["_models.RadiologyInsightsData"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyInsightsModelConfiguration(_model_base.Model):
+    """Configuration affecting the Radiology Insights model's inference.
+
+    :ivar verbose: An indication whether the model should produce verbose output.
+    :vartype verbose: bool
+    :ivar include_evidence: An indication whether the model's output should include evidence for
+     the inferences.
+    :vartype include_evidence: bool
+    :ivar inference_types: This is a list of inference types to be inferred for the current
+     request. It could be used if only part of the Radiology Insights inferences are required. If
+     this list is omitted or empty, the model will return all the inference types.
+    :vartype inference_types: list[str or
+     ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsInferenceType]
+    :ivar inference_options: Options regarding follow up recommendation inferences and finding
+     inferences.
+    :vartype inference_options:
+     ~azure.healthinsights.radiologyinsights.models.RadiologyInsightsInferenceOptions
+    :ivar locale: Local for the model to use. If not specified, the model will use the default
+     locale.
+    :vartype locale: str
+    """
+
+    verbose: Optional[bool] = rest_field()
+    """An indication whether the model should produce verbose output."""
+    include_evidence: Optional[bool] = rest_field(name="includeEvidence")
+    """An indication whether the model's output should include evidence for the inferences."""
+    inference_types: Optional[List[Union[str, "_models.RadiologyInsightsInferenceType"]]] = rest_field(
+        name="inferenceTypes"
+    )
+    """This is a list of inference types to be inferred for the current request. It could be used if
+     only part of the Radiology Insights inferences are required. If this list is omitted or empty,
+     the model will return all the inference types."""
+    inference_options: Optional["_models.RadiologyInsightsInferenceOptions"] = rest_field(name="inferenceOptions")
+    """Options regarding follow up recommendation inferences and finding inferences."""
+    locale: Optional[str] = rest_field()
+    """Local for the model to use. If not specified, the model will use the default locale."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        verbose: Optional[bool] = None,
+        include_evidence: Optional[bool] = None,
+        inference_types: Optional[List[Union[str, "_models.RadiologyInsightsInferenceType"]]] = None,
+        inference_options: Optional["_models.RadiologyInsightsInferenceOptions"] = None,
+        locale: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyInsightsPatientResult(_model_base.Model):
+    """Results of the model's work for a single patient.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar patient_id: Identifier given for the patient in the request. Required.
+    :vartype patient_id: str
+    :ivar inferences: The model's inferences for the given patient. Required.
+    :vartype inferences:
+     list[~azure.healthinsights.radiologyinsights.models.RadiologyInsightsInference]
+    """
+
+    patient_id: str = rest_field(name="patientId")
+    """Identifier given for the patient in the request. Required."""
+    inferences: List["_models.RadiologyInsightsInference"] = rest_field()
+    """The model's inferences for the given patient. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        patient_id: str,
+        inferences: List["_models.RadiologyInsightsInference"],
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RadiologyProcedureInference(RadiologyInsightsInference, discriminator="radiologyProcedure"):
+    """Radiology procedures are the specific imaging studies or examinations ordered for the patient,
+    extracted from the document information and text.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Radiology Procedure inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.RADIOLOGY_PROCEDURE
+    :ivar procedure_codes: LOINC codes for the procedure.
+    :vartype procedure_codes: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar imaging_procedures: Imaging procedures. Required.
+    :vartype imaging_procedures:
+     list[~azure.healthinsights.radiologyinsights.models.ImagingProcedure]
+    :ivar ordered_procedure: Ordered procedure information from the document information or text.
+     Required.
+    :vartype ordered_procedure: ~azure.healthinsights.radiologyinsights.models.OrderedProcedure
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.RADIOLOGY_PROCEDURE] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Radiology Procedure inference type"""
+    procedure_codes: Optional[List["_models.CodeableConcept"]] = rest_field(name="procedureCodes")
+    """LOINC codes for the procedure."""
+    imaging_procedures: List["_models.ImagingProcedure"] = rest_field(name="imagingProcedures")
+    """Imaging procedures. Required."""
+    ordered_procedure: "_models.OrderedProcedure" = rest_field(name="orderedProcedure")
+    """Ordered procedure information from the document information or text. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        imaging_procedures: List["_models.ImagingProcedure"],
+        ordered_procedure: "_models.OrderedProcedure",
+        extension: Optional[List["_models.Extension"]] = None,
+        procedure_codes: Optional[List["_models.CodeableConcept"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.RADIOLOGY_PROCEDURE, **kwargs)
+
+
+class Range(Element):
+    """A set of ordered Quantities defined by a low and high limit
+    Based on `FHIR Range <https://www.hl7.org/fhir/R4/datatypes.html#Range>`_.
+
+    :ivar low: Low limit.
+    :vartype low: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar high: High limit.
+    :vartype high: ~azure.healthinsights.radiologyinsights.models.Quantity
+    """
+
+    low: Optional["_models.Quantity"] = rest_field()
+    """Low limit."""
+    high: Optional["_models.Quantity"] = rest_field()
+    """High limit."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        low: Optional["_models.Quantity"] = None,
+        high: Optional["_models.Quantity"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Ratio(Element):
+    """A ratio of two Quantity values - a numerator and a denominator
+    Based on `FHIR Ratio <https://www.hl7.org/fhir/R4/datatypes.html#Ratio>`_.
+
+    :ivar numerator: Numerator value.
+    :vartype numerator: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar denominator: Denominator value.
+    :vartype denominator: ~azure.healthinsights.radiologyinsights.models.Quantity
+    """
+
+    numerator: Optional["_models.Quantity"] = rest_field()
+    """Numerator value."""
+    denominator: Optional["_models.Quantity"] = rest_field()
+    """Denominator value."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        numerator: Optional["_models.Quantity"] = None,
+        denominator: Optional["_models.Quantity"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RecommendationFinding(_model_base.Model):
+    """Finding reference for recommendation.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar finding: Finding linked to a recommendation.
+    :vartype finding: ~azure.healthinsights.radiologyinsights.models.Observation
+    :ivar critical_finding: Critical result linked to a recommendation.
+    :vartype critical_finding: ~azure.healthinsights.radiologyinsights.models.CriticalResult
+    :ivar recommendation_finding_status: Recommendation finding status. Required. Known values are:
+     "present", "differential", "ruleOut", and "conditional".
+    :vartype recommendation_finding_status: str or
+     ~azure.healthinsights.radiologyinsights.models.RecommendationFindingStatusType
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    """
+
+    finding: Optional["_models.Observation"] = rest_field()
+    """Finding linked to a recommendation."""
+    critical_finding: Optional["_models.CriticalResult"] = rest_field(name="criticalFinding")
+    """Critical result linked to a recommendation."""
+    recommendation_finding_status: Union[str, "_models.RecommendationFindingStatusType"] = rest_field(
+        name="recommendationFindingStatus"
+    )
+    """Recommendation finding status. Required. Known values are: \"present\", \"differential\",
+     \"ruleOut\", and \"conditional\"."""
+    extension: Optional[List["_models.Extension"]] = rest_field()
+    """Additional Content defined by implementations."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        recommendation_finding_status: Union[str, "_models.RecommendationFindingStatusType"],
+        finding: Optional["_models.Observation"] = None,
+        critical_finding: Optional["_models.CriticalResult"] = None,
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class Reference(Element):
+    """A reference from one resource to another
+    Based on `FHIR Reference <https://www.hl7.org/fhir/R4/references.html>`_.
+
+    :ivar reference: Literal reference, Relative, internal or absolute URL.
+    :vartype reference: str
+    :ivar type: Type the reference refers to (e.g. "Patient").
+    :vartype type: str
+    :ivar identifier: Logical reference, when literal reference is not known.
+    :vartype identifier: ~azure.healthinsights.radiologyinsights.models.Identifier
+    :ivar display: Text alternative for the resource.
+    :vartype display: str
+    """
+
+    reference: Optional[str] = rest_field()
+    """Literal reference, Relative, internal or absolute URL."""
+    type: Optional[str] = rest_field()
+    """Type the reference refers to (e.g. \"Patient\")."""
+    identifier: Optional["_models.Identifier"] = rest_field()
+    """Logical reference, when literal reference is not known."""
+    display: Optional[str] = rest_field()
+    """Text alternative for the resource."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reference: Optional[str] = None,
+        type: Optional[str] = None,
+        identifier: Optional["_models.Identifier"] = None,
+        display: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class RequestIdResponseHeader(_model_base.Model):
+    """Provides the 'x-ms-request-id' header to enable request correlation in responses."""
+
+
+class ResearchStudy(DomainResource, discriminator="ResearchStudy"):  # pylint: disable=too-many-instance-attributes
+    """Detailed information about Research Study
+    Based on `FHIR ResearchStudy <https://www.hl7.org/fhir/R4/researchstudy.html>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar id: Resource Id.
+    :vartype id: str
+    :ivar meta: Metadata about the resource.
+    :vartype meta: ~azure.healthinsights.radiologyinsights.models.Meta
+    :ivar implicit_rules: A set of rules under which this content was created.
+    :vartype implicit_rules: str
+    :ivar language: Language of the resource content.
+    :vartype language: str
+    :ivar text: Text summary of the resource, for human interpretation.
+    :vartype text: ~azure.healthinsights.radiologyinsights.models.Narrative
+    :ivar contained: Contained, inline Resources.
+    :vartype contained: list[~azure.healthinsights.radiologyinsights.models.Resource]
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar modifier_extension: Extensions that cannot be ignored.
+    :vartype modifier_extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar resource_type: resourceType. Required. Default value is "ResearchStudy".
+    :vartype resource_type: str
+    :ivar identifier: Business Identifier for study.
+    :vartype identifier: list[~azure.healthinsights.radiologyinsights.models.Identifier]
+    :ivar title: Name for this study.
+    :vartype title: str
+    :ivar protocol: Steps followed in executing study.
+    :vartype protocol: list[~azure.healthinsights.radiologyinsights.models.Reference]
+    :ivar part_of: Part of larger study.
+    :vartype part_of: list[~azure.healthinsights.radiologyinsights.models.Reference]
+    :ivar status: active | administratively-completed | approved | closed-to-accrual |
+     closed-to-accrual-and-intervention | completed | disapproved | in-review |
+     temporarily-closed-to-accrual | temporarily-closed-to-accrual-and-intervention | withdrawn.
+     Required. Known values are: "active", "administratively-completed", "approved",
+     "closed-to-accrual", "closed-to-accrual-and-intervention", "completed", "disapproved",
+     "in-review", "temporarily-closed-to-accrual", "temporarily-closed-to-accrual-and-intervention",
+     and "withdrawn".
+    :vartype status: str or
+     ~azure.healthinsights.radiologyinsights.models.ResearchStudyStatusCodeType
+    :ivar primary_purpose_type: treatment | prevention | diagnostic | supportive-care | screening |
+     health-services-research | basic-science | device-feasibility.
+    :vartype primary_purpose_type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar phase: n-a | early-phase-1 | phase-1 | phase-1-phase-2 | phase-2 | phase-2-phase-3 |
+     phase-3 | phase-4.
+    :vartype phase: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar category: Classifications for the study.
+    :vartype category: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar focus: Drugs, devices, etc. under study.
+    :vartype focus: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar condition: Condition being studied.
+    :vartype condition: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar contact: Contact details for the study.
+    :vartype contact: list[~azure.healthinsights.radiologyinsights.models.ContactDetail]
+    :ivar keyword: Used to search for the study.
+    :vartype keyword: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar location: Geographic region(s) for study.
+    :vartype location: list[~azure.healthinsights.radiologyinsights.models.CodeableConcept]
+    :ivar description: What this is study doing.
+    :vartype description: str
+    :ivar enrollment: Inclusion & exclusion criteria.
+    :vartype enrollment: list[~azure.healthinsights.radiologyinsights.models.Reference]
+    :ivar period: When the study began and ended.
+    :vartype period: ~azure.healthinsights.radiologyinsights.models.Period
+    :ivar sponsor: Organization that initiates and is legally responsible for the study.
+    :vartype sponsor: ~azure.healthinsights.radiologyinsights.models.Reference
+    :ivar principal_investigator: Researcher who oversees multiple aspects of the study.
+    :vartype principal_investigator: ~azure.healthinsights.radiologyinsights.models.Reference
+    :ivar site: Facility where study activities are conducted.
+    :vartype site: list[~azure.healthinsights.radiologyinsights.models.Reference]
+    :ivar reason_stopped: accrual-goal-met | closed-due-to-toxicity |
+     closed-due-to-lack-of-study-progress | temporarily-closed-per-study-design.
+    :vartype reason_stopped: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar note: Comments made about the study.
+    :vartype note: list[~azure.healthinsights.radiologyinsights.models.Annotation]
+    :ivar arm: Defined path through the study for a subject.
+    :vartype arm: list[~azure.healthinsights.radiologyinsights.models.ResearchStudyArm]
+    :ivar objective: A goal for the study.
+    :vartype objective: list[~azure.healthinsights.radiologyinsights.models.ResearchStudyObjective]
+    """
+
+    resource_type: Literal["ResearchStudy"] = rest_discriminator(name="resourceType")  # type: ignore
+    """resourceType. Required. Default value is \"ResearchStudy\"."""
+    identifier: Optional[List["_models.Identifier"]] = rest_field()
+    """Business Identifier for study."""
+    title: Optional[str] = rest_field()
+    """Name for this study."""
+    protocol: Optional[List["_models.Reference"]] = rest_field()
+    """Steps followed in executing study."""
+    part_of: Optional[List["_models.Reference"]] = rest_field(name="partOf")
+    """Part of larger study."""
+    status: Union[str, "_models.ResearchStudyStatusCodeType"] = rest_field()
+    """active | administratively-completed | approved | closed-to-accrual |
+     closed-to-accrual-and-intervention | completed | disapproved | in-review |
+     temporarily-closed-to-accrual | temporarily-closed-to-accrual-and-intervention | withdrawn.
+     Required. Known values are: \"active\", \"administratively-completed\", \"approved\",
+     \"closed-to-accrual\", \"closed-to-accrual-and-intervention\", \"completed\", \"disapproved\",
+     \"in-review\", \"temporarily-closed-to-accrual\",
+     \"temporarily-closed-to-accrual-and-intervention\", and \"withdrawn\"."""
+    primary_purpose_type: Optional["_models.CodeableConcept"] = rest_field(name="primaryPurposeType")
+    """treatment | prevention | diagnostic | supportive-care | screening | health-services-research |
+     basic-science | device-feasibility."""
+    phase: Optional["_models.CodeableConcept"] = rest_field()
+    """n-a | early-phase-1 | phase-1 | phase-1-phase-2 | phase-2 | phase-2-phase-3 | phase-3 |
+     phase-4."""
+    category: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """Classifications for the study."""
+    focus: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """Drugs, devices, etc. under study."""
+    condition: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """Condition being studied."""
+    contact: Optional[List["_models.ContactDetail"]] = rest_field()
+    """Contact details for the study."""
+    keyword: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """Used to search for the study."""
+    location: Optional[List["_models.CodeableConcept"]] = rest_field()
+    """Geographic region(s) for study."""
+    description: Optional[str] = rest_field()
+    """What this is study doing."""
+    enrollment: Optional[List["_models.Reference"]] = rest_field()
+    """Inclusion & exclusion criteria."""
+    period: Optional["_models.Period"] = rest_field()
+    """When the study began and ended."""
+    sponsor: Optional["_models.Reference"] = rest_field()
+    """Organization that initiates and is legally responsible for the study."""
+    principal_investigator: Optional["_models.Reference"] = rest_field(name="principalInvestigator")
+    """Researcher who oversees multiple aspects of the study."""
+    site: Optional[List["_models.Reference"]] = rest_field()
+    """Facility where study activities are conducted."""
+    reason_stopped: Optional["_models.CodeableConcept"] = rest_field(name="reasonStopped")
+    """accrual-goal-met | closed-due-to-toxicity | closed-due-to-lack-of-study-progress |
+     temporarily-closed-per-study-design."""
+    note: Optional[List["_models.Annotation"]] = rest_field()
+    """Comments made about the study."""
+    arm: Optional[List["_models.ResearchStudyArm"]] = rest_field()
+    """Defined path through the study for a subject."""
+    objective: Optional[List["_models.ResearchStudyObjective"]] = rest_field()
+    """A goal for the study."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Union[str, "_models.ResearchStudyStatusCodeType"],
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        meta: Optional["_models.Meta"] = None,
+        implicit_rules: Optional[str] = None,
+        language: Optional[str] = None,
+        text: Optional["_models.Narrative"] = None,
+        contained: Optional[List["_models.Resource"]] = None,
+        extension: Optional[List["_models.Extension"]] = None,
+        modifier_extension: Optional[List["_models.Extension"]] = None,
+        identifier: Optional[List["_models.Identifier"]] = None,
+        title: Optional[str] = None,
+        protocol: Optional[List["_models.Reference"]] = None,
+        part_of: Optional[List["_models.Reference"]] = None,
+        primary_purpose_type: Optional["_models.CodeableConcept"] = None,
+        phase: Optional["_models.CodeableConcept"] = None,
+        category: Optional[List["_models.CodeableConcept"]] = None,
+        focus: Optional[List["_models.CodeableConcept"]] = None,
+        condition: Optional[List["_models.CodeableConcept"]] = None,
+        contact: Optional[List["_models.ContactDetail"]] = None,
+        keyword: Optional[List["_models.CodeableConcept"]] = None,
+        location: Optional[List["_models.CodeableConcept"]] = None,
+        description: Optional[str] = None,
+        enrollment: Optional[List["_models.Reference"]] = None,
+        period: Optional["_models.Period"] = None,
+        sponsor: Optional["_models.Reference"] = None,
+        principal_investigator: Optional["_models.Reference"] = None,
+        site: Optional[List["_models.Reference"]] = None,
+        reason_stopped: Optional["_models.CodeableConcept"] = None,
+        note: Optional[List["_models.Annotation"]] = None,
+        arm: Optional[List["_models.ResearchStudyArm"]] = None,
+        objective: Optional[List["_models.ResearchStudyObjective"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, resource_type="ResearchStudy", **kwargs)
+
+
+class ResearchStudyArm(_model_base.Model):
+    """ResearchStudyArm.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar name: Label for study arm. Required.
+    :vartype name: str
+    :ivar type: Categorization of study arm.
+    :vartype type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    :ivar description: Short explanation of study path.
+    :vartype description: str
+    """
+
+    name: str = rest_field()
+    """Label for study arm. Required."""
+    type: Optional["_models.CodeableConcept"] = rest_field()
+    """Categorization of study arm."""
+    description: Optional[str] = rest_field()
+    """Short explanation of study path."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: str,
+        type: Optional["_models.CodeableConcept"] = None,
+        description: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class ResearchStudyObjective(_model_base.Model):
+    """ResearchStudyObjective.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar name: Label for the objective. Required.
+    :vartype name: str
+    :ivar type: primary | secondary | exploratory.
+    :vartype type: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    """
+
+    name: str = rest_field()
+    """Label for the objective. Required."""
+    type: Optional["_models.CodeableConcept"] = rest_field()
+    """primary | secondary | exploratory."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: str,
+        type: Optional["_models.CodeableConcept"] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class SampledData(Element):
+    """A series of measurements taken by a device
+    Based on `FHIR SampledData <https://www.hl7.org/fhir/R4/datatypes.html#SampledData>`_.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar origin: Zero value and units. Required.
+    :vartype origin: ~azure.healthinsights.radiologyinsights.models.Quantity
+    :ivar period: Number of milliseconds between samples. Required.
+    :vartype period: float
+    :ivar factor: Multiply data by this before adding to origin.
+    :vartype factor: float
+    :ivar lower_limit: Lower limit of detection.
+    :vartype lower_limit: float
+    :ivar upper_limit: Upper limit of detection.
+    :vartype upper_limit: float
+    :ivar dimensions: Number of sample points at each time point. Required.
+    :vartype dimensions: int
+    :ivar data: Decimal values with spaces, or "E" | "U" | "L".
+    :vartype data: str
+    """
+
+    origin: "_models.Quantity" = rest_field()
+    """Zero value and units. Required."""
+    period: float = rest_field()
+    """Number of milliseconds between samples. Required."""
+    factor: Optional[float] = rest_field()
+    """Multiply data by this before adding to origin."""
+    lower_limit: Optional[float] = rest_field(name="lowerLimit")
+    """Lower limit of detection."""
+    upper_limit: Optional[float] = rest_field(name="upperLimit")
+    """Upper limit of detection."""
+    dimensions: int = rest_field()
+    """Number of sample points at each time point. Required."""
+    data: Optional[str] = rest_field()
+    """Decimal values with spaces, or \"E\" | \"U\" | \"L\"."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        origin: "_models.Quantity",
+        period: float,
+        dimensions: int,
+        factor: Optional[float] = None,
+        lower_limit: Optional[float] = None,
+        upper_limit: Optional[float] = None,
+        data: Optional[str] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
+
+
+class SexMismatchInference(RadiologyInsightsInference, discriminator="sexMismatch"):
+    """A notification for a sex mismatch is displayed when the gender, personal pronouns,
+    gender-related body parts, or gender-related procedures mentioned in a patient's clinical
+    document are either inconsistent or do not match the gender specified in the patient
+    information.
+
+    All required parameters must be populated in order to send to server.
+
+    :ivar extension: Additional Content defined by implementations.
+    :vartype extension: list[~azure.healthinsights.radiologyinsights.models.Extension]
+    :ivar kind: Inference type. Required. Sex mismatch inference type
+    :vartype kind: str or ~azure.healthinsights.radiologyinsights.models.SEX_MISMATCH
+    :ivar sex_indication: Sex indication : SNOMED CT code for gender finding. Required.
+    :vartype sex_indication: ~azure.healthinsights.radiologyinsights.models.CodeableConcept
+    """
+
+    kind: Literal[RadiologyInsightsInferenceType.SEX_MISMATCH] = rest_discriminator(name="kind")  # type: ignore
+    """Inference type. Required. Sex mismatch inference type"""
+    sex_indication: "_models.CodeableConcept" = rest_field(name="sexIndication")
+    """Sex indication : SNOMED CT code for gender finding. Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        sex_indication: "_models.CodeableConcept",
+        extension: Optional[List["_models.Extension"]] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, kind=RadiologyInsightsInferenceType.SEX_MISMATCH, **kwargs)
+
+
+class TimePeriod(_model_base.Model):
+    """A duration of time during which an event is happening.
+
+    :ivar start: Starting time with inclusive boundary.
+    :vartype start: ~datetime.datetime
+    :ivar end: End time with inclusive boundary, if not ongoing.
+    :vartype end: ~datetime.datetime
+    """
+
+    start: Optional[datetime.datetime] = rest_field(format="rfc3339")
+    """Starting time with inclusive boundary."""
+    end: Optional[datetime.datetime] = rest_field(format="rfc3339")
+    """End time with inclusive boundary, if not ongoing."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        start: Optional[datetime.datetime] = None,
+        end: Optional[datetime.datetime] = None,
+    ):
+        ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]):
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+        super().__init__(*args, **kwargs)
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_patch.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_patch.py
new file mode 100644
index 0000000000000..f7dd32510333d
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/models/_patch.py
@@ -0,0 +1,20 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Customize generated code here.
+
+Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
+"""
+from typing import List
+
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+
+
+def patch_sdk():
+    """Do not remove from this file.
+
+    `patch_sdk` is a last resort escape hatch that allows you to do customizations
+    you can't accomplish using the techniques described in
+    https://aka.ms/azsdk/python/dpcodegen/python/customize
+    """
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/py.typed b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/py.typed
new file mode 100644
index 0000000000000..e5aff4f83af86
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/azure/healthinsights/radiologyinsights/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561.
\ No newline at end of file
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/dev_requirements.txt b/sdk/healthinsights/azure-healthinsights-radiologyinsights/dev_requirements.txt
new file mode 100644
index 0000000000000..ff12ab35dd010
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/dev_requirements.txt
@@ -0,0 +1,4 @@
+-e ../../../tools/azure-devtools
+-e ../../../tools/azure-sdk-tools
+../../core/azure-core
+aiohttp
\ No newline at end of file
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/sdk_packaging.toml b/sdk/healthinsights/azure-healthinsights-radiologyinsights/sdk_packaging.toml
new file mode 100644
index 0000000000000..e7687fdae93bc
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/sdk_packaging.toml
@@ -0,0 +1,2 @@
+[packaging]
+auto_update = false
\ No newline at end of file
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/setup.py b/sdk/healthinsights/azure-healthinsights-radiologyinsights/setup.py
new file mode 100644
index 0000000000000..3ed094517a649
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/setup.py
@@ -0,0 +1,71 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+# coding: utf-8
+
+import os
+import re
+from setuptools import setup, find_packages
+
+
+PACKAGE_NAME = "azure-healthinsights-radiologyinsights"
+PACKAGE_PPRINT_NAME = "Azure Health Insights - Radiology Insights"
+
+# a-b-c => a/b/c
+package_folder_path = PACKAGE_NAME.replace("-", "/")
+
+# Version extraction inspired from 'requests'
+with open(os.path.join(package_folder_path, "_version.py"), "r") as fd:
+    version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1)
+
+if not version:
+    raise RuntimeError("Cannot find version information")
+
+
+setup(
+    name=PACKAGE_NAME,
+    version=version,
+    description="Microsoft {} Client Library for Python".format(PACKAGE_PPRINT_NAME),
+    long_description=open("README.md", "r").read(),
+    long_description_content_type="text/markdown",
+    license="MIT License",
+    author="Microsoft Corporation",
+    author_email="azpysdkhelp@microsoft.com",
+    url="https://github.com/Azure/azure-sdk-for-python/tree/main/sdk",
+    keywords="azure, azure sdk",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3 :: Only",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "License :: OSI Approved :: MIT License",
+    ],
+    zip_safe=False,
+    packages=find_packages(
+        exclude=[
+            "tests",
+            # Exclude packages that will be covered by PEP420 or nspkg
+            "azure",
+            "azure.healthinsights",
+        ]
+    ),
+    include_package_data=True,
+    package_data={
+        "azure.healthinsights.radiologyinsights": ["py.typed"],
+    },
+    install_requires=[
+        "isodate<1.0.0,>=0.6.1",
+        "azure-core<2.0.0,>=1.30.0",
+        "typing-extensions>=4.6.0",
+    ],
+    python_requires=">=3.8",
+)
diff --git a/sdk/healthinsights/azure-healthinsights-radiologyinsights/tsp-location.yaml b/sdk/healthinsights/azure-healthinsights-radiologyinsights/tsp-location.yaml
new file mode 100644
index 0000000000000..6571c969f30e7
--- /dev/null
+++ b/sdk/healthinsights/azure-healthinsights-radiologyinsights/tsp-location.yaml
@@ -0,0 +1,7 @@
+repo: Azure/azure-rest-api-specs
+additionalDirectories:
+- specification/ai/HealthInsights/HealthInsights.Common/
+- specification/ai/HealthInsights/HealthInsights.OpenAPI/
+directory: specification/ai/HealthInsights/HealthInsights.RadiologyInsights
+commit: 9ce05f612a099a0363ca952ea3fd751d71a9bf16
+
diff --git a/sdk/healthinsights/ci.yml b/sdk/healthinsights/ci.yml
index f59f6e7bf0d88..243fdb38e7beb 100644
--- a/sdk/healthinsights/ci.yml
+++ b/sdk/healthinsights/ci.yml
@@ -37,3 +37,5 @@ extends:
     - name: azure-healthinsights-clinicalmatching
       safeName: azurehealthinsightsclinicalmatching
       skipVerifyChangeLog: true
+    - name: azure-healthinsights-radiologyinsights
+      safeName: azurehealthinsightsradiologyinsights