azure-ai-textanalytics 5.3.0b1__py3-none-any.whl → 6.0.0b1__py3-none-any.whl

azure/ai/textanalytics/aio/_text_analytics_client_async.py

@@ -1,1800 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-# pylint: disable=too-many-lines
-
-from typing import Union, Any, List, Dict, cast
-from azure.core.async_paging import AsyncItemPaged
-from azure.core.tracing.decorator_async import distributed_trace_async
-from azure.core.exceptions import HttpResponseError
-from azure.core.credentials import AzureKeyCredential
-from azure.core.credentials_async import AsyncTokenCredential
-from ._base_client_async import AsyncTextAnalyticsClientBase
-from .._request_handlers import (
-    _validate_input,
-    _determine_action_type,
-)
-from .._validate import validate_multiapi_args, check_for_unsupported_actions_types
-from .._response_handlers import (
-    process_http_response_error,
-    entities_result,
-    linked_entities_result,
-    key_phrases_result,
-    sentiment_result,
-    language_result,
-    pii_entities_result,
-    _get_result_from_continuation_token,
-    dynamic_classification_result,
-)
-from ._response_handlers_async import healthcare_paged_result, analyze_paged_result
-from .._models import (
-    DetectLanguageInput,
-    TextDocumentInput,
-    DetectLanguageResult,
-    RecognizeEntitiesResult,
-    RecognizeLinkedEntitiesResult,
-    ExtractKeyPhrasesResult,
-    AnalyzeSentimentResult,
-    DocumentError,
-    RecognizePiiEntitiesResult,
-    RecognizeEntitiesAction,
-    RecognizePiiEntitiesAction,
-    ExtractKeyPhrasesAction,
-    _AnalyzeActionsType,
-    RecognizeLinkedEntitiesAction,
-    AnalyzeSentimentAction,
-    AnalyzeHealthcareEntitiesResult,
-    RecognizeCustomEntitiesAction,
-    RecognizeCustomEntitiesResult,
-    SingleLabelClassifyAction,
-    MultiLabelClassifyAction,
-    ClassifyDocumentResult,
-    AnalyzeHealthcareEntitiesAction,
-    ExtractSummaryAction,
-    ExtractSummaryResult,
-    AbstractSummaryAction,
-    AbstractSummaryResult,
-    DynamicClassificationResult,
-)
-from .._check import is_language_api, string_index_type_compatibility
-from .._lro import TextAnalyticsOperationResourcePolling
-from ._lro_async import (
-    AsyncAnalyzeHealthcareEntitiesLROPollingMethod,
-    AsyncAnalyzeActionsLROPollingMethod,
-    AsyncAnalyzeHealthcareEntitiesLROPoller,
-    AsyncAnalyzeActionsLROPoller,
-    AsyncTextAnalysisLROPoller,
-)
-
-
-AsyncAnalyzeActionsResponse = AsyncTextAnalysisLROPoller[
-    AsyncItemPaged[
-        List[
-            Union[
-                RecognizeEntitiesResult,
-                RecognizeLinkedEntitiesResult,
-                RecognizePiiEntitiesResult,
-                ExtractKeyPhrasesResult,
-                AnalyzeSentimentResult,
-                RecognizeCustomEntitiesResult,
-                ClassifyDocumentResult,
-                AnalyzeHealthcareEntitiesResult,
-                ExtractSummaryResult,
-                AbstractSummaryResult,
-                DocumentError,
-            ]
-        ]
-    ]
-]
-
-
-class TextAnalyticsClient(AsyncTextAnalyticsClientBase):
-    """The Language service API is a suite of natural language processing (NLP) skills built with the best-in-class
-    Microsoft machine learning algorithms. The API can be used to analyze unstructured text for
-    tasks such as sentiment analysis, key phrase extraction, entities recognition,
-    and language detection, and more.
-
-    Further documentation can be found in
-    https://docs.microsoft.com/azure/cognitive-services/language-service/overview
-
-    :param str endpoint: Supported Cognitive Services or Language resource
-        endpoints (protocol and hostname, for example: 'https://<resource-name>.cognitiveservices.azure.com').
-    :param credential: Credentials needed for the client to connect to Azure.
-        This can be the an instance of AzureKeyCredential if using a Cognitive Services/Language API key
-        or a token credential from :mod:`azure.identity`.
-    :type credential: ~azure.core.credentials.AzureKeyCredential or ~azure.core.credentials_async.AsyncTokenCredential
-    :keyword str default_country_hint: Sets the default country_hint to use for all operations.
-        Defaults to "US". If you don't want to use a country hint, pass the string "none".
-    :keyword str default_language: Sets the default language to use for all operations.
-        Defaults to "en".
-    :keyword api_version: The API version of the service to use for requests. It defaults to the
-        latest service version. Setting to an older version may result in reduced feature compatibility.
-    :paramtype api_version: str or ~azure.ai.textanalytics.TextAnalyticsApiVersion
-
-    .. admonition:: Example:
-
-        .. literalinclude:: ../samples/async_samples/sample_authentication_async.py
-            :start-after: [START create_ta_client_with_key_async]
-            :end-before: [END create_ta_client_with_key_async]
-            :language: python
-            :dedent: 4
-            :caption: Creating the TextAnalyticsClient with endpoint and API key.
-
-        .. literalinclude:: ../samples/async_samples/sample_authentication_async.py
-            :start-after: [START create_ta_client_with_aad_async]
-            :end-before: [END create_ta_client_with_aad_async]
-            :language: python
-            :dedent: 4
-            :caption: Creating the TextAnalyticsClient with endpoint and token credential from Azure Active Directory.
-    """
-
-    def __init__(
-        self,
-        endpoint: str,
-        credential: Union[AzureKeyCredential, AsyncTokenCredential],
-        **kwargs: Any
-    ) -> None:
-        super().__init__(
-            endpoint=endpoint, credential=credential, **kwargs
-        )
-
-        self._default_language = kwargs.pop("default_language", "en")
-        self._default_country_hint = kwargs.pop("default_country_hint", "US")
-        self._string_code_unit = (
-            None if kwargs.get("api_version") == "v3.0" else "UnicodeCodePoint"
-        )
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.0",
-        args_mapping={"v3.1": ["disable_service_logs"]}
-    )
-    async def detect_language(
-        self,
-        documents: Union[List[str], List[DetectLanguageInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> List[Union[DetectLanguageResult, DocumentError]]:
-        """Detect language for a batch of documents.
-
-        Returns the detected language and a numeric score between zero and
-        one. Scores close to one indicate 100% certainty that the identified
-        language is true. See https://aka.ms/talangs for the list of enabled languages.
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and country_hint on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.DetectLanguageInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.DetectLanguageInput`, like
-            `{"id": "1", "country_hint": "us", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.DetectLanguageInput] or list[dict[str, str]]
-        :keyword str country_hint: Country of origin hint for the entire batch. Accepts two
-            letter country codes specified by ISO 3166-1 alpha-2. Per-document
-            country hints will take precedence over whole batch hints. Defaults to
-            "US". If you don't want to use a country hint, pass the string "none".
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.DetectLanguageResult`
-            and :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents
-            were passed in.
-        :rtype: list[~azure.ai.textanalytics.DetectLanguageResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *disable_service_logs* keyword argument.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_detect_language_async.py
-                :start-after: [START detect_language_async]
-                :end-before: [END detect_language_async]
-                :language: python
-                :dedent: 4
-                :caption: Detecting language in a batch of documents.
-        """
-        country_hint_arg = kwargs.pop("country_hint", None)
-        country_hint = (
-            country_hint_arg
-            if country_hint_arg is not None
-            else self._default_country_hint
-        )
-        docs = _validate_input(documents, "country_hint", country_hint)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-
-        try:
-            if is_language_api(self._api_version):
-                models = self._client.models(api_version=self._api_version)
-                return cast(
-                    List[Union[DetectLanguageResult, DocumentError]],
-                    await self._client.analyze_text(
-                        body=models.AnalyzeTextLanguageDetectionInput(
-                            analysis_input={"documents": docs},
-                            parameters=models.LanguageDetectionTaskParameters(
-                                logging_opt_out=disable_service_logs,
-                                model_version=model_version
-                            )
-                        ),
-                        show_stats=show_stats,
-                        cls=kwargs.pop("cls", language_result),
-                        **kwargs
-                    )
-                )
-
-            # api_versions 3.0, 3.1
-            return cast(
-                List[Union[DetectLanguageResult, DocumentError]],
-                await self._client.languages(
-                    documents=docs,
-                    model_version=model_version,
-                    show_stats=show_stats,
-                    logging_opt_out=disable_service_logs,
-                    cls=kwargs.pop("cls", language_result),
-                    **kwargs
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.0",
-        args_mapping={"v3.1": ["string_index_type", "disable_service_logs"]}
-    )
-    async def recognize_entities(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> List[Union[RecognizeEntitiesResult, DocumentError]]:
-        """Recognize entities for a batch of documents.
-
-        Identifies and categorizes entities in your text as people, places,
-        organizations, date/time, quantities, percentages, currencies, and more.
-        For the list of supported entity types, check: https://aka.ms/taner
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            If not set, uses "en" for English as default. Per-document language will
-            take precedence over whole batch language. See https://aka.ms/talangs for
-            supported languages in Language API.
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword str string_index_type: Specifies the method used to interpret string offsets.
-            `UnicodeCodePoint`, the Python encoding, is the default. To override the Python default,
-            you can also pass in `Utf16CodeUnit` or `TextElement_v8`. For additional information
-            see https://aka.ms/text-analytics-offsets
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.RecognizeEntitiesResult` and
-            :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents were
-            passed in.
-        :rtype: list[~azure.ai.textanalytics.RecognizeEntitiesResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *disable_service_logs* and *string_index_type* keyword arguments.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_recognize_entities_async.py
-                :start-after: [START recognize_entities_async]
-                :end-before: [END recognize_entities_async]
-                :language: python
-                :dedent: 4
-                :caption: Recognize entities in a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        docs = _validate_input(documents, "language", language)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        string_index_type = kwargs.pop("string_index_type", self._string_code_unit)
-
-        try:
-            if is_language_api(self._api_version):
-                models = self._client.models(api_version=self._api_version)
-                return cast(
-                    List[Union[RecognizeEntitiesResult, DocumentError]],
-                    await self._client.analyze_text(
-                        body=models.AnalyzeTextEntityRecognitionInput(
-                            analysis_input={"documents": docs},
-                            parameters=models.EntitiesTaskParameters(
-                                logging_opt_out=disable_service_logs,
-                                model_version=model_version,
-                                string_index_type=string_index_type_compatibility(string_index_type)
-                            )
-                        ),
-                        show_stats=show_stats,
-                        cls=kwargs.pop("cls", entities_result),
-                        **kwargs
-                    )
-                )
-
-            # api_versions 3.0, 3.1
-            return cast(
-                List[Union[RecognizeEntitiesResult, DocumentError]],
-                await self._client.entities_recognition_general(
-                    documents=docs,
-                    model_version=model_version,
-                    show_stats=show_stats,
-                    string_index_type=string_index_type,
-                    logging_opt_out=disable_service_logs,
-                    cls=kwargs.pop("cls", entities_result),
-                    **kwargs,
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.1"
-    )
-    async def recognize_pii_entities(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> List[Union[RecognizePiiEntitiesResult, DocumentError]]:
-        """Recognize entities containing personal information for a batch of documents.
-
-        Returns a list of personal information entities ("SSN",
-        "Bank Account", etc) in the document.  For the list of supported entity types,
-        check https://aka.ms/tanerpii
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            If not set, uses "en" for English as default. Per-document language will
-            take precedence over whole batch language. See https://aka.ms/talangs for
-            supported languages in Language API.
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword domain_filter: Filters the response entities to ones only included in the specified domain.
-            I.e., if set to 'phi', will only return entities in the Protected Healthcare Information domain.
-            See https://aka.ms/tanerpii for more information.
-        :paramtype domain_filter: str or ~azure.ai.textanalytics.PiiEntityDomain
-        :keyword categories_filter: Instead of filtering over all PII entity categories, you can pass in a list of
-            the specific PII entity categories you want to filter out. For example, if you only want to filter out
-            U.S. social security numbers in a document, you can pass in
-            `[PiiEntityCategory.US_SOCIAL_SECURITY_NUMBER]` for this kwarg.
-        :paramtype categories_filter: list[str or ~azure.ai.textanalytics.PiiEntityCategory]
-        :keyword str string_index_type: Specifies the method used to interpret string offsets.
-            `UnicodeCodePoint`, the Python encoding, is the default. To override the Python default,
-            you can also pass in `Utf16CodeUnit` or `TextElement_v8`. For additional information
-            see https://aka.ms/text-analytics-offsets
-        :keyword bool disable_service_logs: Defaults to true, meaning that the Language service will not log your
-            input text on the service side for troubleshooting. If set to False, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.RecognizePiiEntitiesResult`
-            and :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents
-            were passed in.
-        :rtype: list[~azure.ai.textanalytics.RecognizePiiEntitiesResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *recognize_pii_entities* client method.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/sample_recognize_pii_entities.py
-                :start-after: [START recognize_pii_entities]
-                :end-before: [END recognize_pii_entities]
-                :language: python
-                :dedent: 4
-                :caption: Recognize personally identifiable information entities in a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        docs = _validate_input(documents, "language", language)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        domain_filter = kwargs.pop("domain_filter", None)
-        categories_filter = kwargs.pop("categories_filter", None)
-        string_index_type = kwargs.pop("string_index_type", self._string_code_unit)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-
-        try:
-            if is_language_api(self._api_version):
-                models = self._client.models(api_version=self._api_version)
-                return cast(
-                    List[Union[RecognizePiiEntitiesResult, DocumentError]],
-                    await self._client.analyze_text(
-                        body=models.AnalyzeTextPiiEntitiesRecognitionInput(
-                            analysis_input={"documents": docs},
-                            parameters=models.PiiTaskParameters(
-                                logging_opt_out=disable_service_logs,
-                                model_version=model_version,
-                                domain=domain_filter,
-                                pii_categories=categories_filter,
-                                string_index_type=string_index_type_compatibility(string_index_type)
-                            )
-                        ),
-                        show_stats=show_stats,
-                        cls=kwargs.pop("cls", pii_entities_result),
-                        **kwargs
-                    )
-                )
-
-            # api_versions 3.0, 3.1
-            return cast(
-                List[Union[RecognizePiiEntitiesResult, DocumentError]],
-                await self._client.entities_recognition_pii(
-                    documents=docs,
-                    model_version=model_version,
-                    show_stats=show_stats,
-                    domain=domain_filter,
-                    pii_categories=categories_filter,
-                    logging_opt_out=disable_service_logs,
-                    string_index_type=string_index_type,
-                    cls=kwargs.pop("cls", pii_entities_result),
-                    **kwargs
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.0",
-        args_mapping={"v3.1": ["string_index_type", "disable_service_logs"]}
-    )
-    async def recognize_linked_entities(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> List[Union[RecognizeLinkedEntitiesResult, DocumentError]]:
-        """Recognize linked entities from a well-known knowledge base for a batch of documents.
-
-        Identifies and disambiguates the identity of each entity found in text (for example,
-        determining whether an occurrence of the word Mars refers to the planet, or to the
-        Roman god of war). Recognized entities are associated with URLs to a well-known
-        knowledge base, like Wikipedia.
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            If not set, uses "en" for English as default. Per-document language will
-            take precedence over whole batch language. See https://aka.ms/talangs for
-            supported languages in Language API.
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword str string_index_type: Specifies the method used to interpret string offsets.
-            `UnicodeCodePoint`, the Python encoding, is the default. To override the Python default,
-            you can also pass in `Utf16CodeUnit` or `TextElement_v8`. For additional information
-            see https://aka.ms/text-analytics-offsets
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.RecognizeLinkedEntitiesResult`
-            and :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents
-            were passed in.
-        :rtype: list[~azure.ai.textanalytics.RecognizeLinkedEntitiesResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *disable_service_logs* and *string_index_type* keyword arguments.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_recognize_linked_entities_async.py
-                :start-after: [START recognize_linked_entities_async]
-                :end-before: [END recognize_linked_entities_async]
-                :language: python
-                :dedent: 4
-                :caption: Recognize linked entities in a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        docs = _validate_input(documents, "language", language)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        string_index_type = kwargs.pop("string_index_type", self._string_code_unit)
-
-        try:
-            if is_language_api(self._api_version):
-                models = self._client.models(api_version=self._api_version)
-                return cast(
-                    List[Union[RecognizeLinkedEntitiesResult, DocumentError]],
-                    await self._client.analyze_text(
-                        body=models.AnalyzeTextEntityLinkingInput(
-                            analysis_input={"documents": docs},
-                            parameters=models.EntityLinkingTaskParameters(
-                                logging_opt_out=disable_service_logs,
-                                model_version=model_version,
-                                string_index_type=string_index_type_compatibility(string_index_type)
-                            )
-                        ),
-                        show_stats=show_stats,
-                        cls=kwargs.pop("cls", linked_entities_result),
-                        **kwargs
-                    )
-                )
-
-            # api_versions 3.0, 3.1
-            return cast(
-                List[Union[RecognizeLinkedEntitiesResult, DocumentError]],
-                await self._client.entities_linking(
-                    documents=docs,
-                    logging_opt_out=disable_service_logs,
-                    model_version=model_version,
-                    string_index_type=string_index_type,
-                    show_stats=show_stats,
-                    cls=kwargs.pop("cls", linked_entities_result),
-                    **kwargs
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.0",
-        args_mapping={"v3.1": ["disable_service_logs"]}
-    )
-    async def extract_key_phrases(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> List[Union[ExtractKeyPhrasesResult, DocumentError]]:
-        """Extract key phrases from a batch of documents.
-
-        Returns a list of strings denoting the key phrases in the input
-        text. For example, for the input text "The food was delicious and there
-        were wonderful staff", the API returns the main talking points: "food"
-        and "wonderful staff"
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            If not set, uses "en" for English as default. Per-document language will
-            take precedence over whole batch language. See https://aka.ms/talangs for
-            supported languages in Language API.
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.ExtractKeyPhrasesResult` and
-            :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents were
-            passed in.
-        :rtype: list[~azure.ai.textanalytics.ExtractKeyPhrasesResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *disable_service_logs* keyword argument.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_extract_key_phrases_async.py
-                :start-after: [START extract_key_phrases_async]
-                :end-before: [END extract_key_phrases_async]
-                :language: python
-                :dedent: 4
-                :caption: Extract the key phrases in a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        docs = _validate_input(documents, "language", language)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-
-        try:
-            if is_language_api(self._api_version):
-                models = self._client.models(api_version=self._api_version)
-                return cast(
-                    List[Union[ExtractKeyPhrasesResult, DocumentError]],
-                    await self._client.analyze_text(
-                        body=models.AnalyzeTextKeyPhraseExtractionInput(
-                            analysis_input={"documents": docs},
-                            parameters=models.KeyPhraseTaskParameters(
-                                logging_opt_out=disable_service_logs,
-                                model_version=model_version,
-                            )
-                        ),
-                        show_stats=show_stats,
-                        cls=kwargs.pop("cls", key_phrases_result),
-                        **kwargs
-                    )
-                )
-
-            # api_versions 3.0, 3.1
-            return cast(
-                List[Union[ExtractKeyPhrasesResult, DocumentError]],
-                await self._client.key_phrases(
-                    documents=docs,
-                    model_version=model_version,
-                    show_stats=show_stats,
-                    logging_opt_out=disable_service_logs,
-                    cls=kwargs.pop("cls", key_phrases_result),
-                    **kwargs
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.0",
-        args_mapping={"v3.1": ["show_opinion_mining", "disable_service_logs", "string_index_type"]}
-    )
-    async def analyze_sentiment(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> List[Union[AnalyzeSentimentResult, DocumentError]]:
-        """Analyze sentiment for a batch of documents. Turn on opinion mining with `show_opinion_mining`.
-
-        Returns a sentiment prediction, as well as sentiment scores for
-        each sentiment class (Positive, Negative, and Neutral) for the document
-        and each sentence within it.
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :keyword bool show_opinion_mining: Whether to mine the opinions of a sentence and conduct more
-            granular analysis around the aspects of a product or service (also known as
-            aspect-based sentiment analysis). If set to true, the returned
-            :class:`~azure.ai.textanalytics.SentenceSentiment` objects
-            will have property `mined_opinions` containing the result of this analysis. Only available for
-            API version v3.1 and up.
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            If not set, uses "en" for English as default. Per-document language will
-            take precedence over whole batch language. See https://aka.ms/talangs for
-            supported languages in Language API.
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword str string_index_type: Specifies the method used to interpret string offsets.
-            `UnicodeCodePoint`, the Python encoding, is the default. To override the Python default,
-            you can also pass in `Utf16CodeUnit` or `TextElement_v8`. For additional information
-            see https://aka.ms/text-analytics-offsets
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.AnalyzeSentimentResult` and
-            :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents were
-            passed in.
-        :rtype: list[~azure.ai.textanalytics.AnalyzeSentimentResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *show_opinion_mining*, *disable_service_logs*, and *string_index_type* keyword arguments.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_analyze_sentiment_async.py
-                :start-after: [START analyze_sentiment_async]
-                :end-before: [END analyze_sentiment_async]
-                :language: python
-                :dedent: 4
-                :caption: Analyze sentiment in a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        docs = _validate_input(documents, "language", language)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        show_opinion_mining = kwargs.pop("show_opinion_mining", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        string_index_type = kwargs.pop("string_index_type", self._string_code_unit)
-
-        try:
-            if is_language_api(self._api_version):
-                models = self._client.models(api_version=self._api_version)
-                return cast(
-                    List[Union[AnalyzeSentimentResult, DocumentError]],
-                    await self._client.analyze_text(
-                        body=models.AnalyzeTextSentimentAnalysisInput(
-                            analysis_input={"documents": docs},
-                            parameters=models.SentimentAnalysisTaskParameters(
-                                logging_opt_out=disable_service_logs,
-                                model_version=model_version,
-                                string_index_type=string_index_type_compatibility(string_index_type),
-                                opinion_mining=show_opinion_mining,
-                            )
-                        ),
-                        show_stats=show_stats,
-                        cls=kwargs.pop("cls", sentiment_result),
-                        **kwargs
-                    )
-                )
-
-            # api_versions 3.0, 3.1
-            return cast(
-                List[Union[AnalyzeSentimentResult, DocumentError]],
-                await self._client.sentiment(
-                    documents=docs,
-                    logging_opt_out=disable_service_logs,
-                    model_version=model_version,
-                    string_index_type=string_index_type,
-                    opinion_mining=show_opinion_mining,
-                    show_stats=show_stats,
-                    cls=kwargs.pop("cls", sentiment_result),
-                    **kwargs
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    # pylint: disable=unused-argument
-    def _healthcare_result_callback(
-        self, raw_response, deserialized, doc_id_order, task_id_order=None, show_stats=False, bespoke=False
-    ):
-        if deserialized is None:
-            models = self._client.models(api_version=self._api_version)
-            response_cls = \
-                models.AnalyzeTextJobState if is_language_api(self._api_version) else models.HealthcareJobState
-            deserialized = response_cls.deserialize(raw_response)
-        return healthcare_paged_result(
-            doc_id_order,
-            self._client.analyze_text_job_status if is_language_api(self._api_version) else self._client.health_status,
-            raw_response,
-            deserialized,
-            show_stats=show_stats,
-        )
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.1",
-        args_mapping={
-            "2022-10-01-preview": ["fhir_version", "document_type", "autodetect_default_language"],
-            "2022-05-01": ["display_name"]
-        }
-    )
-    async def begin_analyze_healthcare_entities(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        **kwargs: Any,
-    ) -> AsyncAnalyzeHealthcareEntitiesLROPoller[
-        AsyncItemPaged[Union[AnalyzeHealthcareEntitiesResult, DocumentError]]
-    ]:
-        """Analyze healthcare entities and identify relationships between these entities in a batch of documents.
-
-        Entities are associated with references that can be found in existing knowledge bases,
-        such as UMLS, CHV, MSH, etc.
-
-        We also extract the relations found between entities, for example in "The subject took 100 mg of ibuprofen",
-        we would extract the relationship between the "100 mg" dosage and the "ibuprofen" medication.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document level statistics.
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            For automatic language detection, use "auto" (Only supported by API version
-            2022-10-01-preview and newer). If not set, uses "en" for English as default.
-            Per-document language will take precedence over whole batch language.
-            See https://aka.ms/talangs for supported languages in Language API.
-        :keyword str autodetect_default_language: Default/fallback language to use for documents requesting
-            automatic language detection.
-        :keyword str display_name: An optional display name to set for the requested analysis.
-        :keyword str string_index_type: Specifies the method used to interpret string offsets.
-            Can be one of 'UnicodeCodePoint' (default), 'Utf16CodeUnit', or 'TextElement_v8'.
-            For additional information see https://aka.ms/text-analytics-offsets
-        :keyword int polling_interval: Waiting time between two polls for LRO operations
-            if no Retry-After header is present. Defaults to 5 seconds.
-        :keyword str continuation_token:
-            Call `continuation_token()` on the poller object to save the long-running operation (LRO)
-            state into an opaque token. Pass the value as the `continuation_token` keyword argument
-            to restart the LRO from a saved state.
-        :keyword bool disable_service_logs: Defaults to true, meaning that the Language service will not log your
-            input text on the service side for troubleshooting. If set to False, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the Text Analytics natural language processing functions. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :keyword str fhir_version: The FHIR Spec version that the result will use to format the fhir_bundle
-            on the result object. For additional information see https://www.hl7.org/fhir/overview.html.
-            The only acceptable values to pass in are None and "4.0.1". The default value is None.
-        :keyword document_type: Document type that can be provided as input for Fhir Documents. Expect to
-            have fhir_version provided when used. Behavior of using None enum is the same as not using the
-            document_type parameter. Known values are: "None", "ClinicalTrial", "DischargeSummary",
-            "ProgressNote", "HistoryAndPhysical", "Consult", "Imaging", "Pathology", and "ProcedureNote".
-        :paramtype document_type: str or ~azure.ai.textanalytics.HealthcareDocumentType
-        :return: An instance of an AsyncAnalyzeHealthcareEntitiesLROPoller. Call `result()` on the poller
-            object to return a heterogeneous pageable of
-            :class:`~azure.ai.textanalytics.AnalyzeHealthcareEntitiesResult` and
-            :class:`~azure.ai.textanalytics.DocumentError`.
-        :rtype:
-            ~azure.ai.textanalytics.aio.AsyncAnalyzeHealthcareEntitiesLROPoller[~azure.core.async_paging.AsyncItemPaged[
-            ~azure.ai.textanalytics.AnalyzeHealthcareEntitiesResult or ~azure.ai.textanalytics.DocumentError]]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *begin_analyze_healthcare_entities* client method.
-        .. versionadded:: 2022-05-01
-            The *display_name* keyword argument.
-        .. versionadded:: 2022-10-01-preview
-            The *fhir_version*, *document_type*, and *autodetect_default_language* keyword arguments.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_analyze_healthcare_entities_async.py
-                :start-after: [START analyze_healthcare_entities_async]
-                :end-before: [END analyze_healthcare_entities_async]
-                :language: python
-                :dedent: 4
-                :caption: Analyze healthcare entities in a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        polling_interval = kwargs.pop("polling_interval", 5)
-        continuation_token = kwargs.pop("continuation_token", None)
-        string_index_type = kwargs.pop("string_index_type", self._string_code_unit)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        display_name = kwargs.pop("display_name", None)
-        fhir_version = kwargs.pop("fhir_version", None)
-        document_type = kwargs.pop("document_type", None)
-        autodetect_default_language = kwargs.pop("autodetect_default_language", None)
-
-        if continuation_token:
-            return cast(
-                AsyncAnalyzeHealthcareEntitiesLROPoller[
-                    AsyncItemPaged[Union[AnalyzeHealthcareEntitiesResult, DocumentError]]
-                ],
-                _get_result_from_continuation_token(
-                    self._client._client,  # pylint: disable=protected-access
-                    continuation_token,
-                    AsyncAnalyzeHealthcareEntitiesLROPoller,
-                    AsyncAnalyzeHealthcareEntitiesLROPollingMethod(
-                        text_analytics_client=self._client,
-                        timeout=polling_interval,
-                        **kwargs
-                    ),
-                    self._healthcare_result_callback
-                )
-            )
-
-        docs = _validate_input(documents, "language", language)
-        doc_id_order = [doc.get("id") for doc in docs]
-        my_cls = kwargs.pop(
-            "cls",
-            lambda pipeline_response, deserialized, _: self._healthcare_result_callback(
-                pipeline_response, deserialized, doc_id_order, show_stats=show_stats
-            ),
-        )
-        models = self._client.models(api_version=self._api_version)
-
-        try:
-            if is_language_api(self._api_version):
-                docs = models.MultiLanguageAnalysisInput(
-                    documents=_validate_input(documents, "language", language)
-                )
-                return cast(
-                    AsyncAnalyzeHealthcareEntitiesLROPoller[
-                        AsyncItemPaged[Union[AnalyzeHealthcareEntitiesResult, DocumentError]]
-                    ],
-                    await self._client.begin_analyze_text_submit_job(  # type: ignore
-                        body=models.AnalyzeTextJobsInput(
-                            analysis_input=docs,
-                            display_name=display_name,
-                            default_language=autodetect_default_language,
-                            tasks=[
-                                models.HealthcareLROTask(
-                                    task_name="0",
-                                    parameters=models.HealthcareTaskParameters(
-                                        model_version=model_version,
-                                        logging_opt_out=disable_service_logs,
-                                        string_index_type=string_index_type_compatibility(string_index_type),
-                                        fhir_version=fhir_version,
-                                        document_type=document_type,
-                                    )
-                                )
-                            ]
-                        ),
-                        cls=my_cls,
-                        polling=AsyncAnalyzeHealthcareEntitiesLROPollingMethod(
-                            text_analytics_client=self._client,
-                            timeout=polling_interval,
-                            show_stats=show_stats,
-                            doc_id_order=doc_id_order,
-                            lro_algorithms=[
-                                TextAnalyticsOperationResourcePolling(
-                                    show_stats=show_stats,
-                                )
-                            ],
-                            **kwargs
-                        ),
-                        continuation_token=continuation_token,
-                        poller_cls=AsyncAnalyzeHealthcareEntitiesLROPoller,
-                        **kwargs
-                    )
-                )
-
-            # v3.1
-            return cast(
-                AsyncAnalyzeHealthcareEntitiesLROPoller[
-                    AsyncItemPaged[Union[AnalyzeHealthcareEntitiesResult, DocumentError]]
-                ],
-                await self._client.begin_health(
-                    docs,
-                    model_version=model_version,
-                    string_index_type=string_index_type,
-                    logging_opt_out=disable_service_logs,
-                    cls=my_cls,
-                    polling=AsyncAnalyzeHealthcareEntitiesLROPollingMethod(
-                        text_analytics_client=self._client,
-                        doc_id_order=doc_id_order,
-                        show_stats=show_stats,
-                        timeout=polling_interval,
-                        lro_algorithms=[
-                            TextAnalyticsOperationResourcePolling(
-                                show_stats=show_stats,
-                            )
-                        ],
-                        **kwargs,
-                    ),
-                    continuation_token=continuation_token,
-                    **kwargs,
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    def _analyze_result_callback(
-        self, raw_response, deserialized, doc_id_order, task_id_order=None, show_stats=False, bespoke=False
-    ):
-
-        if deserialized is None:
-            models = self._client.models(api_version=self._api_version)
-            response_cls = models.AnalyzeTextJobState if is_language_api(self._api_version) else models.AnalyzeJobState
-            deserialized = response_cls.deserialize(raw_response)
-        return analyze_paged_result(
-            doc_id_order,
-            task_id_order,
-            self._client.analyze_text_job_status if is_language_api(self._api_version) else self._client.analyze_status,
-            raw_response,
-            deserialized,
-            show_stats=show_stats,
-            bespoke=bespoke
-        )
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="v3.1",
-        custom_wrapper=check_for_unsupported_actions_types,
-        args_mapping={
-            "2022-10-01-preview": ["autodetect_default_language"],
-        }
-    )
-    async def begin_analyze_actions(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        actions: List[
-            Union[
-                RecognizeEntitiesAction,
-                RecognizeLinkedEntitiesAction,
-                RecognizePiiEntitiesAction,
-                ExtractKeyPhrasesAction,
-                AnalyzeSentimentAction,
-                RecognizeCustomEntitiesAction,
-                SingleLabelClassifyAction,
-                MultiLabelClassifyAction,
-                AnalyzeHealthcareEntitiesAction,
-                ExtractSummaryAction,
-                AbstractSummaryAction,
-            ]
-        ],
-        **kwargs: Any,
-    ) -> AsyncTextAnalysisLROPoller[
-        AsyncItemPaged[
-            List[
-                Union[
-                    RecognizeEntitiesResult,
-                    RecognizeLinkedEntitiesResult,
-                    RecognizePiiEntitiesResult,
-                    ExtractKeyPhrasesResult,
-                    AnalyzeSentimentResult,
-                    RecognizeCustomEntitiesResult,
-                    ClassifyDocumentResult,
-                    AnalyzeHealthcareEntitiesResult,
-                    ExtractSummaryResult,
-                    AbstractSummaryResult,
-                    DocumentError,
-                ]
-            ]
-        ]
-    ]:
-        """Start a long-running operation to perform a variety of text analysis actions over a batch of documents.
-
-        We recommend you use this function if you're looking to analyze larger documents, and / or
-        combine multiple text analysis actions into one call. Otherwise, we recommend you use
-        the action specific endpoints, for example :func:`analyze_sentiment`.
-
-        .. note:: The abstractive summarization feature is part of a gated preview. Request access here:
-            https://aka.ms/applyforgatedsummarizationfeatures
-
-        .. note:: See the service documentation for regional support of custom action features:
-            https://aka.ms/azsdk/textanalytics/customfunctionalities
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :param actions: A heterogeneous list of actions to perform on the input documents.
-            Each action object encapsulates the parameters used for the particular action type.
-            The action results will be in the same order of the input actions.
-        :type actions:
-            list[RecognizeEntitiesAction or RecognizePiiEntitiesAction or ExtractKeyPhrasesAction or
-            RecognizeLinkedEntitiesAction or AnalyzeSentimentAction or
-            RecognizeCustomEntitiesAction or SingleLabelClassifyAction or
-            MultiLabelClassifyAction or AnalyzeHealthcareEntitiesAction or
-            AbstractSummaryAction or ExtractSummaryAction]
-        :keyword str display_name: An optional display name to set for the requested analysis.
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            For automatic language detection, use "auto" (Only supported by API version
-            2022-10-01-preview and newer). If not set, uses "en" for English as default.
-            Per-document language will take precedence over whole batch language.
-            See https://aka.ms/talangs for supported languages in Language API.
-        :keyword str autodetect_default_language: Default/fallback language to use for documents requesting
-            automatic language detection.
-        :keyword bool show_stats: If set to true, response will contain document level statistics.
-        :keyword int polling_interval: Waiting time between two polls for LRO operations
-            if no Retry-After header is present. Defaults to 5 seconds.
-        :keyword str continuation_token:
-            Call `continuation_token()` on the poller object to save the long-running operation (LRO)
-            state into an opaque token. Pass the value as the `continuation_token` keyword argument
-            to restart the LRO from a saved state.
-        :return: An instance of an AsyncTextAnalysisLROPoller. Call `result()` on the poller
-            object to return a pageable heterogeneous list of lists. This list of lists is first ordered
-            by the documents you input, then ordered by the actions you input. For example,
-            if you have documents input ["Hello", "world"], and actions
-            :class:`~azure.ai.textanalytics.RecognizeEntitiesAction` and
-            :class:`~azure.ai.textanalytics.AnalyzeSentimentAction`, when iterating over the list of lists,
-            you will first iterate over the action results for the "Hello" document, getting the
-            :class:`~azure.ai.textanalytics.RecognizeEntitiesResult` of "Hello",
-            then the :class:`~azure.ai.textanalytics.AnalyzeSentimentResult` of "Hello".
-            Then, you will get the :class:`~azure.ai.textanalytics.RecognizeEntitiesResult` and
-            :class:`~azure.ai.textanalytics.AnalyzeSentimentResult` of "world".
-        :rtype:
-            ~azure.ai.textanalytics.aio.AsyncTextAnalysisLROPoller[~azure.core.async_paging.AsyncItemPaged[
-            list[RecognizeEntitiesResult or RecognizeLinkedEntitiesResult or RecognizePiiEntitiesResult or
-            ExtractKeyPhrasesResult or AnalyzeSentimentResult or RecognizeCustomEntitiesResult
-            or ClassifyDocumentResult or AnalyzeHealthcareEntitiesResult or ExtractSummaryResult
-            or AbstractSummaryResult or DocumentError]]]
-        :raises ~azure.core.exceptions.HttpResponseError or TypeError or ValueError:
-
-        .. versionadded:: v3.1
-            The *begin_analyze_actions* client method.
-        .. versionadded:: 2022-05-01
-            The *RecognizeCustomEntitiesAction*, *SingleLabelClassifyAction*,
-            *MultiLabelClassifyAction*, and *AnalyzeHealthcareEntitiesAction* input options and the
-            corresponding *RecognizeCustomEntitiesResult*, *ClassifyDocumentResult*,
-            and *AnalyzeHealthcareEntitiesResult* result objects
-        .. versionadded:: 2022-10-01-preview
-            The *ExtractSummaryAction* and *AbstractSummaryAction* input options and the corresponding
-            *ExtractSummaryResult* and *AbstractSummaryResult* result objects.
-            The *autodetect_default_language* keyword argument.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_analyze_actions_async.py
-                :start-after: [START analyze_async]
-                :end-before: [END analyze_async]
-                :language: python
-                :dedent: 4
-                :caption: Start a long-running operation to perform a variety of text analysis actions over
-                    a batch of documents.
-        """
-
-        display_name = kwargs.pop("display_name", None)
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-
-        show_stats = kwargs.pop("show_stats", None)
-        polling_interval = kwargs.pop("polling_interval", 5)
-        continuation_token = kwargs.pop("continuation_token", None)
-        bespoke = kwargs.pop("bespoke", False)
-        autodetect_default_language = kwargs.pop("autodetect_default_language", None)
-
-        if continuation_token:
-            return cast(
-                AsyncAnalyzeActionsResponse,
-                _get_result_from_continuation_token(
-                    self._client._client,  # pylint: disable=protected-access
-                    continuation_token,
-                    AsyncAnalyzeActionsLROPoller,
-                    AsyncAnalyzeActionsLROPollingMethod(
-                        text_analytics_client=self._client,
-                        timeout=polling_interval,
-                        **kwargs
-                    ),
-                    self._analyze_result_callback,
-                    bespoke
-                )
-            )
-
-        models = self._client.models(api_version=self._api_version)
-
-        input_model_cls = \
-            models.MultiLanguageAnalysisInput if is_language_api(self._api_version) else models.MultiLanguageBatchInput
-        docs = input_model_cls(
-            documents=_validate_input(documents, "language", language)
-        )
-        doc_id_order = [doc.get("id") for doc in docs.documents]
-        try:
-            generated_tasks = [
-                action._to_generated(self._api_version, str(idx))  # pylint: disable=protected-access
-                for idx, action in enumerate(actions)
-            ]
-        except AttributeError as e:
-            raise TypeError("Unsupported action type in list.") from e
-        task_order = [(_determine_action_type(a), a.task_name) for a in generated_tasks]
-
-        response_cls = kwargs.pop(
-            "cls",
-            lambda pipeline_response, deserialized, _:
-                self._analyze_result_callback(
-                    pipeline_response,
-                    deserialized,
-                    doc_id_order,
-                    task_id_order=task_order,
-                    show_stats=show_stats,
-                    bespoke=bespoke
-                ),
-        )
-
-        try:
-            if is_language_api(self._api_version):
-                return cast(
-                    AsyncAnalyzeActionsResponse,
-                    await self._client.begin_analyze_text_submit_job(
-                        body=models.AnalyzeTextJobsInput(
-                            analysis_input=docs,
-                            display_name=display_name,
-                            default_language=autodetect_default_language,
-                            tasks=generated_tasks
-                        ),
-                        cls=response_cls,
-                        polling=AsyncAnalyzeActionsLROPollingMethod(
-                            text_analytics_client=self._client,
-                            timeout=polling_interval,
-                            show_stats=show_stats,
-                            doc_id_order=doc_id_order,
-                            task_id_order=task_order,
-                            lro_algorithms=[
-                                TextAnalyticsOperationResourcePolling(
-                                    show_stats=show_stats,
-                                )
-                            ],
-                            **kwargs
-                        ),
-                        continuation_token=continuation_token,
-                        **kwargs
-                    )
-                )
-
-            # v3.1
-            analyze_tasks = models.JobManifestTasks(
-                entity_recognition_tasks=[
-                    a for a in generated_tasks
-                    if _determine_action_type(a) == _AnalyzeActionsType.RECOGNIZE_ENTITIES
-                ],
-                entity_recognition_pii_tasks=[
-                    a for a in generated_tasks
-                    if _determine_action_type(a) == _AnalyzeActionsType.RECOGNIZE_PII_ENTITIES
-                ],
-                key_phrase_extraction_tasks=[
-                    a for a in generated_tasks
-                    if _determine_action_type(a) == _AnalyzeActionsType.EXTRACT_KEY_PHRASES
-                ],
-                entity_linking_tasks=[
-                    a for a in generated_tasks
-                    if _determine_action_type(a) == _AnalyzeActionsType.RECOGNIZE_LINKED_ENTITIES
-                ],
-                sentiment_analysis_tasks=[
-                    a for a in generated_tasks
-                    if _determine_action_type(a) == _AnalyzeActionsType.ANALYZE_SENTIMENT
-                ],
-            )
-            analyze_body = models.AnalyzeBatchInput(
-                display_name=display_name, tasks=analyze_tasks, analysis_input=docs
-            )
-            return cast(
-                AsyncAnalyzeActionsResponse,
-                await self._client.begin_analyze(
-                    body=analyze_body,
-                    cls=response_cls,
-                    polling=AsyncAnalyzeActionsLROPollingMethod(
-                        text_analytics_client=self._client,
-                        timeout=polling_interval,
-                        show_stats=show_stats,
-                        doc_id_order=doc_id_order,
-                        task_id_order=task_order,
-                        lro_algorithms=[
-                            TextAnalyticsOperationResourcePolling(
-                                show_stats=show_stats,
-                            )
-                        ],
-                        **kwargs,
-                    ),
-                    continuation_token=continuation_token,
-                    **kwargs,
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="2022-05-01",
-        args_mapping={
-            "2022-10-01-preview": ["autodetect_default_language"],
-        }
-    )
-    async def begin_recognize_custom_entities(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        project_name: str,
-        deployment_name: str,
-        **kwargs: Any,
-    ) -> AsyncTextAnalysisLROPoller[AsyncItemPaged[Union[RecognizeCustomEntitiesResult, DocumentError]]]:
-        """Start a long-running custom named entity recognition operation.
-
-        For information on regional support of custom features and how to train a model to
-        recognize custom entities, see https://aka.ms/azsdk/textanalytics/customentityrecognition
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :param str project_name: Required. This field indicates the project name for the model.
-        :param str deployment_name: This field indicates the deployment name for the model.
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            For automatic language detection, use "auto" (Only supported by API version
-            2022-10-01-preview and newer). If not set, uses "en" for English as default.
-            Per-document language will take precedence over whole batch language.
-            See https://aka.ms/talangs for supported languages in Language API.
-        :keyword str autodetect_default_language: Default/fallback language to use for documents requesting
-            automatic language detection.
-        :keyword bool show_stats: If set to true, response will contain document level statistics.
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :keyword str string_index_type: Specifies the method used to interpret string offsets.
-            `UnicodeCodePoint`, the Python encoding, is the default. To override the Python default,
-            you can also pass in `Utf16CodeUnit` or `TextElement_v8`. For additional information
-            see https://aka.ms/text-analytics-offsets
-        :keyword int polling_interval: Waiting time between two polls for LRO operations
-            if no Retry-After header is present. Defaults to 5 seconds.
-        :keyword str continuation_token:
-            Call `continuation_token()` on the poller object to save the long-running operation (LRO)
-            state into an opaque token. Pass the value as the `continuation_token` keyword argument
-            to restart the LRO from a saved state.
-        :keyword str display_name: An optional display name to set for the requested analysis.
-        :return: An instance of an AsyncTextAnalysisLROPoller. Call `result()` on the this
-            object to return a heterogeneous pageable of
-            :class:`~azure.ai.textanalytics.RecognizeCustomEntitiesResult` and
-            :class:`~azure.ai.textanalytics.DocumentError`.
-        :rtype:
-            ~azure.ai.textanalytics.aio.AsyncTextAnalysisLROPoller[~azure.core.async_paging.AsyncItemPaged[
-            ~azure.ai.textanalytics.RecognizeCustomEntitiesResult or ~azure.ai.textanalytics.DocumentError]]
-        :raises ~azure.core.exceptions.HttpResponseError:
-
-        .. versionadded:: 2022-05-01
-            The *begin_recognize_custom_entities* client method.
-        .. versionadded:: 2022-10-01-preview
-            The *autodetect_default_language* keyword argument.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_recognize_custom_entities_async.py
-                :start-after: [START recognize_custom_entities_async]
-                :end-before: [END recognize_custom_entities_async]
-                :language: python
-                :dedent: 4
-                :caption: Recognize custom entities in a batch of documents.
-        """
-
-        continuation_token = kwargs.pop("continuation_token", None)
-        string_index_type = kwargs.pop("string_index_type", self._string_code_unit)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        polling_interval = kwargs.pop("polling_interval", 5)
-
-        if continuation_token:
-            return cast(
-                AsyncTextAnalysisLROPoller[AsyncItemPaged[Union[RecognizeCustomEntitiesResult, DocumentError]]],
-                _get_result_from_continuation_token(
-                    self._client._client,  # pylint: disable=protected-access
-                    continuation_token,
-                    AsyncAnalyzeActionsLROPoller,
-                    AsyncAnalyzeActionsLROPollingMethod(
-                        text_analytics_client=self._client,
-                        timeout=polling_interval,
-                        **kwargs
-                    ),
-                    self._analyze_result_callback,
-                    bespoke=True
-                )
-            )
-
-        try:
-            return cast(
-                AsyncTextAnalysisLROPoller[
-                    AsyncItemPaged[Union[RecognizeCustomEntitiesResult, DocumentError]]
-                ],
-                await self.begin_analyze_actions(
-                    documents,
-                    actions=[
-                        RecognizeCustomEntitiesAction(
-                            project_name=project_name,
-                            deployment_name=deployment_name,
-                            string_index_type=string_index_type,
-                            disable_service_logs=disable_service_logs
-                        )
-                    ],
-                    polling_interval=polling_interval,
-                    bespoke=True,
-                    **kwargs
-                )
-            )
-
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="2022-05-01",
-        args_mapping={
-            "2022-10-01-preview": ["autodetect_default_language"],
-        }
-    )
-    async def begin_single_label_classify(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        project_name: str,
-        deployment_name: str,
-        **kwargs: Any,
-    ) -> AsyncTextAnalysisLROPoller[AsyncItemPaged[Union[ClassifyDocumentResult, DocumentError]]]:
-        """Start a long-running custom single label classification operation.
-
-        For information on regional support of custom features and how to train a model to
-        classify your documents, see https://aka.ms/azsdk/textanalytics/customfunctionalities
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :param str project_name: Required. This field indicates the project name for the model.
-        :param str deployment_name: This field indicates the deployment name for the model.
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            For automatic language detection, use "auto" (Only supported by API version
-            2022-10-01-preview and newer). If not set, uses "en" for English as default.
-            Per-document language will take precedence over whole batch language.
-            See https://aka.ms/talangs for supported languages in Language API.
-        :keyword str autodetect_default_language: Default/fallback language to use for documents requesting
-            automatic language detection.
-        :keyword bool show_stats: If set to true, response will contain document level statistics.
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :keyword int polling_interval: Waiting time between two polls for LRO operations
-            if no Retry-After header is present. Defaults to 5 seconds.
-        :keyword str continuation_token:
-            Call `continuation_token()` on the poller object to save the long-running operation (LRO)
-            state into an opaque token. Pass the value as the `continuation_token` keyword argument
-            to restart the LRO from a saved state.
-        :keyword str display_name: An optional display name to set for the requested analysis.
-        :return: An instance of an AsyncTextAnalysisLROPoller. Call `result()` on the this
-            object to return a heterogeneous pageable of
-            :class:`~azure.ai.textanalytics.ClassifyDocumentResult` and
-            :class:`~azure.ai.textanalytics.DocumentError`.
-        :rtype:
-            ~azure.ai.textanalytics.aio.AsyncTextAnalysisLROPoller[~azure.core.async_paging.AsyncItemPaged[
-            ~azure.ai.textanalytics.ClassifyDocumentResult or ~azure.ai.textanalytics.DocumentError]]
-        :raises ~azure.core.exceptions.HttpResponseError:
-
-        .. versionadded:: 2022-05-01
-            The *begin_single_label_classify* client method.
-        .. versionadded:: 2022-10-01-preview
-            The *autodetect_default_language* keyword argument.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_single_label_classify_async.py
-                :start-after: [START single_label_classify_async]
-                :end-before: [END single_label_classify_async]
-                :language: python
-                :dedent: 4
-                :caption: Perform single label classification on a batch of documents.
-        """
-
-        continuation_token = kwargs.pop("continuation_token", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        polling_interval = kwargs.pop("polling_interval", 5)
-
-        if continuation_token:
-            return cast(
-                AsyncTextAnalysisLROPoller[AsyncItemPaged[Union[ClassifyDocumentResult, DocumentError]]],
-                _get_result_from_continuation_token(
-                    self._client._client,  # pylint: disable=protected-access
-                    continuation_token,
-                    AsyncAnalyzeActionsLROPoller,
-                    AsyncAnalyzeActionsLROPollingMethod(
-                        text_analytics_client=self._client,
-                        timeout=polling_interval,
-                        **kwargs
-                    ),
-                    self._analyze_result_callback,
-                    bespoke=True
-                )
-            )
-
-        try:
-            return cast(
-                AsyncTextAnalysisLROPoller[
-                    AsyncItemPaged[Union[ClassifyDocumentResult, DocumentError]]
-                ],
-                await self.begin_analyze_actions(
-                    documents,
-                    actions=[
-                        SingleLabelClassifyAction(
-                            project_name=project_name,
-                            deployment_name=deployment_name,
-                            disable_service_logs=disable_service_logs
-                        )
-                    ],
-                    polling_interval=polling_interval,
-                    bespoke=True,
-                    **kwargs
-                )
-            )
-
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="2022-05-01",
-        args_mapping={
-            "2022-10-01-preview": ["autodetect_default_language"],
-        }
-    )
-    async def begin_multi_label_classify(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        project_name: str,
-        deployment_name: str,
-        **kwargs: Any,
-    ) -> AsyncTextAnalysisLROPoller[AsyncItemPaged[Union[ClassifyDocumentResult, DocumentError]]]:
-        """Start a long-running custom multi label classification operation.
-
-        For information on regional support of custom features and how to train a model to
-        classify your documents, see https://aka.ms/azsdk/textanalytics/customfunctionalities
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list of
-            dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`, like
-            `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :param str project_name: Required. This field indicates the project name for the model.
-        :param str deployment_name: This field indicates the deployment name for the model.
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            For automatic language detection, use "auto" (Only supported by API version
-            2022-10-01-preview and newer). If not set, uses "en" for English as default.
-            Per-document language will take precedence over whole batch language.
-            See https://aka.ms/talangs for supported languages in Language API.
-        :keyword str autodetect_default_language: Default/fallback language to use for documents requesting
-            automatic language detection.
-        :keyword bool show_stats: If set to true, response will contain document level statistics.
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :keyword int polling_interval: Waiting time between two polls for LRO operations
-            if no Retry-After header is present. Defaults to 5 seconds.
-        :keyword str continuation_token:
-            Call `continuation_token()` on the poller object to save the long-running operation (LRO)
-            state into an opaque token. Pass the value as the `continuation_token` keyword argument
-            to restart the LRO from a saved state.
-        :keyword str display_name: An optional display name to set for the requested analysis.
-        :return: An instance of an AsyncTextAnalysisLROPoller. Call `result()` on the this
-            object to return a heterogeneous pageable of
-            :class:`~azure.ai.textanalytics.ClassifyDocumentResult` and
-            :class:`~azure.ai.textanalytics.DocumentError`.
-        :rtype:
-            ~azure.ai.textanalytics.aio.AsyncTextAnalysisLROPoller[~azure.core.async_paging.AsyncItemPaged[
-            ~azure.ai.textanalytics.ClassifyDocumentResult or ~azure.ai.textanalytics.DocumentError]]
-        :raises ~azure.core.exceptions.HttpResponseError:
-
-        .. versionadded:: 2022-05-01
-            The *begin_multi_label_classify* client method.
-        .. versionadded:: 2022-10-01-preview
-            The *autodetect_default_language* keyword argument.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_multi_label_classify_async.py
-                :start-after: [START multi_label_classify_async]
-                :end-before: [END multi_label_classify_async]
-                :language: python
-                :dedent: 4
-                :caption: Perform multi label classification on a batch of documents.
-        """
-
-        continuation_token = kwargs.pop("continuation_token", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        polling_interval = kwargs.pop("polling_interval", 5)
-
-        if continuation_token:
-            return cast(
-                AsyncTextAnalysisLROPoller[AsyncItemPaged[Union[ClassifyDocumentResult, DocumentError]]],
-                _get_result_from_continuation_token(
-                    self._client._client,  # pylint: disable=protected-access
-                    continuation_token,
-                    AsyncAnalyzeActionsLROPoller,
-                    AsyncAnalyzeActionsLROPollingMethod(
-                        text_analytics_client=self._client,
-                        timeout=polling_interval,
-                        **kwargs
-                    ),
-                    self._analyze_result_callback,
-                    bespoke=True
-                )
-            )
-
-        try:
-            return cast(
-                AsyncTextAnalysisLROPoller[
-                    AsyncItemPaged[Union[ClassifyDocumentResult, DocumentError]]
-                ],
-                await self.begin_analyze_actions(
-                    documents,
-                    actions=[
-                        MultiLabelClassifyAction(
-                            project_name=project_name,
-                            deployment_name=deployment_name,
-                            disable_service_logs=disable_service_logs
-                        )
-                    ],
-                    polling_interval=polling_interval,
-                    bespoke=True,
-                    **kwargs
-                )
-            )
-
-        except HttpResponseError as error:
-            return process_http_response_error(error)
-
-    @distributed_trace_async
-    @validate_multiapi_args(
-        version_method_added="2022-10-01-preview",
-    )
-    async def dynamic_classification(
-        self,
-        documents: Union[List[str], List[TextDocumentInput], List[Dict[str, str]]],
-        categories: List[str],
-        **kwargs: Any,
-    ) -> List[Union[DynamicClassificationResult, DocumentError]]:
-        """Perform dynamic classification on a batch of documents.
-
-        On the fly classification of the input documents into one or multiple categories.
-        Assigns either one or multiple categories per document. This type of classification
-        doesn't require model training.
-
-        .. note:: The dynamic classification feature is part of a gated preview. Request access here:
-            https://aka.ms/applyforgatedlanguagefeature
-
-        See https://aka.ms/azsdk/textanalytics/data-limits for service data limits.
-
-        :param documents: The set of documents to process as part of this batch.
-            If you wish to specify the ID and language on a per-item basis you must
-            use as input a list[:class:`~azure.ai.textanalytics.TextDocumentInput`] or a list
-            of dict representations of :class:`~azure.ai.textanalytics.TextDocumentInput`,
-            like `{"id": "1", "language": "en", "text": "hello world"}`.
-        :type documents:
-            list[str] or list[~azure.ai.textanalytics.TextDocumentInput] or list[dict[str, str]]
-        :param list[str] categories: A list of categories to which input is classified to.
-        :keyword classification_type: Specifies either one or multiple categories per document. Defaults
-            to multi classification which may return more than one class for each document. Known values
-            are: "Single" and "Multi".
-        :paramtype classification_type: str or ~azure.ai.textanalytics.ClassificationType
-        :keyword str language: The 2 letter ISO 639-1 representation of language for the
-            entire batch. For example, use "en" for English; "es" for Spanish etc.
-            If not set, uses "en" for English as default. Per-document language will
-            take precedence over whole batch language. See https://aka.ms/talangs for
-            supported languages in Language API.
-        :keyword str model_version: This value indicates which model will
-            be used for scoring, e.g. "latest", "2019-10-01". If a model-version
-            is not specified, the API will default to the latest, non-preview version.
-            See here for more info: https://aka.ms/text-analytics-model-versioning
-        :keyword bool show_stats: If set to true, response will contain document
-            level statistics in the `statistics` field of the document-level response.
-        :keyword bool disable_service_logs: If set to true, you opt-out of having your text input
-            logged on the service side for troubleshooting. By default, the Language service logs your
-            input text for 48 hours, solely to allow for troubleshooting issues in providing you with
-            the service's natural language processing functions. Setting this parameter to true,
-            disables input logging and may limit our ability to remediate issues that occur. Please see
-            Cognitive Services Compliance and Privacy notes at https://aka.ms/cs-compliance for
-            additional details, and Microsoft Responsible AI principles at
-            https://www.microsoft.com/ai/responsible-ai.
-        :return: The combined list of :class:`~azure.ai.textanalytics.DynamicClassificationResult` and
-            :class:`~azure.ai.textanalytics.DocumentError` in the order the original documents
-            were passed in.
-        :rtype: list[~azure.ai.textanalytics.DynamicClassificationResult or ~azure.ai.textanalytics.DocumentError]
-        :raises ~azure.core.exceptions.HttpResponseError:
-
-        .. versionadded:: 2022-10-01-preview
-            The *dynamic_classification* client method.
-
-        .. admonition:: Example:
-
-            .. literalinclude:: ../samples/async_samples/sample_dynamic_classification_async.py
-                :start-after: [START dynamic_classification_async]
-                :end-before: [END dynamic_classification_async]
-                :language: python
-                :dedent: 4
-                :caption: Perform dynamic classification on a batch of documents.
-        """
-        language_arg = kwargs.pop("language", None)
-        language = language_arg if language_arg is not None else self._default_language
-        docs = _validate_input(documents, "language", language)
-        model_version = kwargs.pop("model_version", None)
-        show_stats = kwargs.pop("show_stats", None)
-        disable_service_logs = kwargs.pop("disable_service_logs", None)
-        classification_type = kwargs.pop("classification_type", None)
-
-        try:
-            models = self._client.models(api_version=self._api_version)
-            return cast(
-                List[Union[DynamicClassificationResult, DocumentError]],
-                await self._client.analyze_text(
-                    body=models.AnalyzeTextDynamicClassificationInput(
-                        analysis_input={"documents": docs},
-                        parameters=models.DynamicClassificationTaskParameters(
-                            categories=categories,
-                            logging_opt_out=disable_service_logs,
-                            model_version=model_version,
-                            classification_type=classification_type,
-                        )
-                    ),
-                    show_stats=show_stats,
-                    cls=kwargs.pop("cls", dynamic_classification_result),
-                    **kwargs
-                )
-            )
-        except HttpResponseError as error:
-            return process_http_response_error(error)