# coding: utf-8

# (C) Copyright IBM Corp. 2019, 2025.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# IBM OpenAPI SDK Code Generator Version: 3.105.0-3c13b041-20250605-193116
"""
IBM Watson&reg; Discovery is a cognitive search and content analytics engine that you can
add to applications to identify patterns, trends and actionable insights to drive better
decision-making. Securely unify structured and unstructured data with pre-enriched
content, and use a simplified query language to eliminate the need for manual filtering of
results.

API Version: 2.0
See: https://cloud.ibm.com/docs/discovery-data
"""

from datetime import datetime
from enum import Enum
from os.path import basename
from typing import BinaryIO, Dict, List, Optional
import json
import sys

from ibm_cloud_sdk_core import BaseService, DetailedResponse
from ibm_cloud_sdk_core.authenticators.authenticator import Authenticator
from ibm_cloud_sdk_core.get_authenticator import get_authenticator_from_environment
from ibm_cloud_sdk_core.utils import convert_list, convert_model, datetime_to_string, string_to_datetime

from .common import get_sdk_headers

##############################################################################
# Service
##############################################################################


class DiscoveryV2(BaseService):
    """The Discovery V2 service."""

    DEFAULT_SERVICE_URL = 'https://api.us-south.discovery.watson.cloud.ibm.com'
    DEFAULT_SERVICE_NAME = 'discovery'

    def __init__(
        self,
        version: str,
        authenticator: Authenticator = None,
        service_name: str = DEFAULT_SERVICE_NAME,
    ) -> None:
        """
        Construct a new client for the Discovery service.

        :param str version: Release date of the version of the API you want to use.
               Specify dates in YYYY-MM-DD format. The current version is `2023-03-31`.

        :param Authenticator authenticator: The authenticator specifies the authentication mechanism.
               Get up to date information from https://github.com/IBM/python-sdk-core/blob/main/README.md
               about initializing the authenticator of your choice.
        """
        if version is None:
            raise ValueError('version must be provided')

        if not authenticator:
            authenticator = get_authenticator_from_environment(service_name)
        BaseService.__init__(self,
                             service_url=self.DEFAULT_SERVICE_URL,
                             authenticator=authenticator)
        self.version = version
        self.configure_service(service_name)

    #########################
    # Projects
    #########################

    def list_projects(
        self,
        **kwargs,
    ) -> DetailedResponse:
        """
        List projects.

        Lists existing projects for this instance.

        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ListProjectsResponse` object
        """

        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_projects',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        url = '/v2/projects'
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_project(
        self,
        name: str,
        type: str,
        *,
        default_query_parameters: Optional['DefaultQueryParams'] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create a project.

        Create a new project for this instance.

        :param str name: The human readable name of this project.
        :param str type: The type of project.
               The `content_intelligence` type is a *Document Retrieval for Contracts*
               project and the `other` type is a *Custom* project.
               The `content_mining` and `content_intelligence` types are available with
               Premium plan managed deployments and installed deployments only.
               The Intelligent Document Processing (IDP) project type is available from
               IBM Cloud-managed instances only.
        :param DefaultQueryParams default_query_parameters: (optional) Default
               query parameters for this project.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ProjectDetails` object
        """

        if name is None:
            raise ValueError('name must be provided')
        if type is None:
            raise ValueError('type must be provided')
        if default_query_parameters is not None:
            default_query_parameters = convert_model(default_query_parameters)
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_project',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
            'type': type,
            'default_query_parameters': default_query_parameters,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        url = '/v2/projects'
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_project(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get project.

        Get details on the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ProjectDetails` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_project',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}'.format(**path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_project(
        self,
        project_id: str,
        *,
        name: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update a project.

        Update the specified project's name.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str name: (optional) The new name to give this project.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ProjectDetails` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_project',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}'.format(**path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_project(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a project.

        Deletes the specified project.
        **Important:** Deleting a project deletes everything that is part of the specified
        project, including all collections.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_project',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}'.format(**path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def list_fields(
        self,
        project_id: str,
        *,
        collection_ids: Optional[List[str]] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        List fields.

        Gets a list of the unique fields (and their types) stored in the specified
        collections.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param List[str] collection_ids: (optional) Comma separated list of the
               collection IDs. If this parameter is not specified, all collections in the
               project are used.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ListFieldsResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_fields',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'collection_ids': convert_list(collection_ids),
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/fields'.format(**path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Collections
    #########################

    def list_collections(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List collections.

        Lists existing collections for the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ListCollectionsResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_collections',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections'.format(**path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_collection(
        self,
        project_id: str,
        name: str,
        *,
        description: Optional[str] = None,
        language: Optional[str] = None,
        ocr_enabled: Optional[bool] = None,
        enrichments: Optional[List['CollectionEnrichment']] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create a collection.

        Create a new collection in the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str name: The name of the collection.
        :param str description: (optional) A description of the collection.
        :param str language: (optional) The language of the collection. For a list
               of supported languages, see the [product
               documentation](/docs/discovery-data?topic=discovery-data-language-support).
        :param bool ocr_enabled: (optional) If set to `true`, optical character
               recognition (OCR) is enabled. For more information, see [Optical character
               recognition](/docs/discovery-data?topic=discovery-data-collections#ocr).
        :param List[CollectionEnrichment] enrichments: (optional) An array of
               enrichments that are applied to this collection. To get a list of
               enrichments that are available for a project, use the [List
               enrichments](#listenrichments) method.
               If no enrichments are specified when the collection is created, the default
               enrichments for the project type are applied. For more information about
               project default settings, see the [product
               documentation](/docs/discovery-data?topic=discovery-data-project-defaults).
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `CollectionDetails` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if name is None:
            raise ValueError('name must be provided')
        if enrichments is not None:
            enrichments = [convert_model(x) for x in enrichments]
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_collection',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
            'description': description,
            'language': language,
            'ocr_enabled': ocr_enabled,
            'enrichments': enrichments,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections'.format(**path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_collection(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get collection details.

        Get details about the specified collection.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `CollectionDetails` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_collection',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_collection(
        self,
        project_id: str,
        collection_id: str,
        *,
        name: Optional[str] = None,
        description: Optional[str] = None,
        ocr_enabled: Optional[bool] = None,
        enrichments: Optional[List['CollectionEnrichment']] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update a collection.

        Updates the specified collection's name, description, enrichments, and
        configuration.
        If you apply normalization rules to data in an existing collection, you must
        initiate reprocessing of the collection. To do so, from the *Manage fields* page
        in the product user interface, temporarily change the data type of a field to
        enable the reprocess button. Change the data type of the field back to its
        original value, and then click **Apply changes and reprocess**.
        To remove a configuration that applies JSON normalization operations as part of
        the conversion phase of ingestion, specify an empty `json_normalizations` object
        (`[]`) in the request.
        To remove a configuration that applies JSON normalization operations after
        enrichments are applied, specify an empty `normalizations` object (`[]`) in the
        request.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str name: (optional) The new name of the collection.
        :param str description: (optional) The new description of the collection.
        :param bool ocr_enabled: (optional) If set to `true`, optical character
               recognition (OCR) is enabled. For more information, see [Optical character
               recognition](/docs/discovery-data?topic=discovery-data-collections#ocr).
        :param List[CollectionEnrichment] enrichments: (optional) An array of
               enrichments that are applied to this collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `CollectionDetails` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if enrichments is not None:
            enrichments = [convert_model(x) for x in enrichments]
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_collection',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
            'description': description,
            'ocr_enabled': ocr_enabled,
            'enrichments': enrichments,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_collection(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a collection.

        Deletes the specified collection from the project. All documents stored in the
        specified collection and not shared is also deleted.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_collection',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Documents
    #########################

    def list_documents(
        self,
        project_id: str,
        collection_id: str,
        *,
        count: Optional[int] = None,
        status: Optional[str] = None,
        has_notices: Optional[bool] = None,
        is_parent: Optional[bool] = None,
        parent_document_id: Optional[str] = None,
        sha256: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        List documents.

        Lists the documents in the specified collection. The list includes only the
        document ID of each document and returns information for up to 10,000 documents.
        **Note**: This method is available only from Cloud Pak for Data version 4.0.9 and
        later installed instances, and from IBM Cloud-managed instances.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param int count: (optional) The maximum number of documents to return. Up
               to 1,000 documents are returned by default. The maximum number allowed is
               10,000.
        :param str status: (optional) Filters the documents to include only
               documents with the specified ingestion status. The options include:
               * `available`: Ingestion is finished and the document is indexed.
               * `failed`: Ingestion is finished, but the document is not indexed because
               of an error.
               * `pending`: The document is uploaded, but the ingestion process is not
               started.
               * `processing`: Ingestion is in progress.
               You can specify one status value or add a comma-separated list of more than
               one status value. For example, `available,failed`.
        :param bool has_notices: (optional) If set to `true`, only documents that
               have notices, meaning documents for which warnings or errors were generated
               during the ingestion, are returned. If set to `false`, only documents that
               don't have notices are returned. If unspecified, no filter based on notices
               is applied.
               Notice details are not available in the result, but you can use the [Query
               collection notices](#querycollectionnotices) method to find details by
               adding the parameter `query=notices.document_id:{document-id}`.
        :param bool is_parent: (optional) If set to `true`, only parent documents,
               meaning documents that were split during the ingestion process and resulted
               in two or more child documents, are returned. If set to `false`, only child
               documents are returned. If unspecified, no filter based on the parent or
               child relationship is applied.
               CSV files, for example, are split into separate documents per line and JSON
               files are split into separate documents per object.
        :param str parent_document_id: (optional) Filters the documents to include
               only child documents that were generated when the specified parent document
               was processed.
        :param str sha256: (optional) Filters the documents to include only
               documents with the specified SHA-256 hash. Format the hash as a hexadecimal
               string.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ListDocumentsResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_documents',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'count': count,
            'status': status,
            'has_notices': has_notices,
            'is_parent': is_parent,
            'parent_document_id': parent_document_id,
            'sha256': sha256,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/documents'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def add_document(
        self,
        project_id: str,
        collection_id: str,
        *,
        file: Optional[BinaryIO] = None,
        filename: Optional[str] = None,
        file_content_type: Optional[str] = None,
        metadata: Optional[str] = None,
        x_watson_discovery_force: Optional[bool] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Add a document.

        Add a document to a collection with optional metadata.
        Returns immediately after the system has accepted the document for processing.
        Use this method to upload a file to the collection. You cannot use this method to
        crawl an external data source.
         * For a list of supported file types, see the [product
        documentation](/docs/discovery-data?topic=discovery-data-collections#supportedfiletypes).
         * You must provide document content, metadata, or both. If the request is missing
        both document content and metadata, it is rejected.
          * You can set the **Content-Type** parameter on the **file** part to indicate
        the media type of the document. If the **Content-Type** parameter is missing or is
        one of the generic media types (for example, `application/octet-stream`), then the
        service attempts to automatically detect the document's media type.
         *  If the document is uploaded to a collection that shares its data with another
        collection, the **X-Watson-Discovery-Force** header must be set to `true`.
         * In curl requests only, you can assign an ID to a document that you add by
        appending the ID to the endpoint
        (`/v2/projects/{project_id}/collections/{collection_id}/documents/{document_id}`).
        If a document already exists with the specified ID, it is replaced.
        For more information about how certain file types and field names are handled when
        a file is added to a collection, see the [product
        documentation](/docs/discovery-data?topic=discovery-data-index-overview#field-name-limits).

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param BinaryIO file: (optional) **Add a document**: The content of the
               document to ingest. For the supported file types and maximum supported file
               size limits when adding a document, see [the
               documentation](/docs/discovery-data?topic=discovery-data-collections#supportedfiletypes).
               **Analyze a document**: The content of the document to analyze but not
               ingest. Only the `application/json` content type is supported by the
               Analyze API. For maximum supported file size limits, see [the product
               documentation](/docs/discovery-data?topic=discovery-data-analyzeapi#analyzeapi-limits).
        :param str filename: (optional) The filename for file.
        :param str file_content_type: (optional) The content type of file.
        :param str metadata: (optional) Add information about the file that you
               want to include in the response.
               The maximum supported metadata file size is 1 MB. Metadata parts larger
               than 1 MB are rejected.
               Example:
                ```
                {
                 "filename": "favorites2.json",
                 "file_type": "json"
                }.
        :param bool x_watson_discovery_force: (optional) When `true`, the uploaded
               document is added to the collection even if the data for that collection is
               shared with other collections.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentAccepted` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {
            'X-Watson-Discovery-Force': x_watson_discovery_force,
        }
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='add_document',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        if file:
            if not filename and hasattr(file, 'name'):
                filename = basename(file.name)
            if not filename:
                raise ValueError('filename must be provided')
            form_data.append(('file', (filename, file, file_content_type or
                                       'application/octet-stream')))
        if metadata:
            form_data.append(('metadata', (None, metadata, 'text/plain')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/documents'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_document(
        self,
        project_id: str,
        collection_id: str,
        document_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get document details.

        Get details about a specific document, whether the document is added by uploading
        a file or by crawling an external data source.
        **Note**: This method is available only from Cloud Pak for Data version 4.0.9 and
        later installed instances, and from IBM Cloud-managed instances.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str document_id: The ID of the document.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentDetails` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if not document_id:
            raise ValueError('document_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_document',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id', 'document_id']
        path_param_values = self.encode_path_vars(project_id, collection_id,
                                                  document_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/documents/{document_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_document(
        self,
        project_id: str,
        collection_id: str,
        document_id: str,
        *,
        file: Optional[BinaryIO] = None,
        filename: Optional[str] = None,
        file_content_type: Optional[str] = None,
        metadata: Optional[str] = None,
        x_watson_discovery_force: Optional[bool] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update a document.

        Replace an existing document or add a document with a specified document ID.
        Starts ingesting a document with optional metadata.
        Use this method to upload a file to a collection. You cannot use this method to
        crawl an external data source.
        If the document is uploaded to a collection that shares its data with another
        collection, the **X-Watson-Discovery-Force** header must be set to `true`.
        **Notes:**
         * Uploading a new document with this method automatically replaces any existing
        document stored with the same document ID.
         * If an uploaded document is split into child documents during ingestion, all
        existing child documents are overwritten, even if the updated version of the
        document has fewer child documents.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str document_id: The ID of the document.
        :param BinaryIO file: (optional) **Add a document**: The content of the
               document to ingest. For the supported file types and maximum supported file
               size limits when adding a document, see [the
               documentation](/docs/discovery-data?topic=discovery-data-collections#supportedfiletypes).
               **Analyze a document**: The content of the document to analyze but not
               ingest. Only the `application/json` content type is supported by the
               Analyze API. For maximum supported file size limits, see [the product
               documentation](/docs/discovery-data?topic=discovery-data-analyzeapi#analyzeapi-limits).
        :param str filename: (optional) The filename for file.
        :param str file_content_type: (optional) The content type of file.
        :param str metadata: (optional) Add information about the file that you
               want to include in the response.
               The maximum supported metadata file size is 1 MB. Metadata parts larger
               than 1 MB are rejected.
               Example:
                ```
                {
                 "filename": "favorites2.json",
                 "file_type": "json"
                }.
        :param bool x_watson_discovery_force: (optional) When `true`, the uploaded
               document is added to the collection even if the data for that collection is
               shared with other collections.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentAccepted` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if not document_id:
            raise ValueError('document_id must be provided')
        headers = {
            'X-Watson-Discovery-Force': x_watson_discovery_force,
        }
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_document',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        if file:
            if not filename and hasattr(file, 'name'):
                filename = basename(file.name)
            if not filename:
                raise ValueError('filename must be provided')
            form_data.append(('file', (filename, file, file_content_type or
                                       'application/octet-stream')))
        if metadata:
            form_data.append(('metadata', (None, metadata, 'text/plain')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id', 'document_id']
        path_param_values = self.encode_path_vars(project_id, collection_id,
                                                  document_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/documents/{document_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_document(
        self,
        project_id: str,
        collection_id: str,
        document_id: str,
        *,
        x_watson_discovery_force: Optional[bool] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a document.

        Deletes the document with the document ID that you specify from the collection.
        Removes uploaded documents from the collection permanently. If you delete a
        document that was added by crawling an external data source, the document will be
        added again with the next scheduled crawl of the data source. The delete function
        removes the document from the collection, not from the external data source.
        **Note:** Files such as CSV or JSON files generate subdocuments when they are
        added to a collection. If you delete a subdocument, and then repeat the action
        that created it, the deleted document is added back in to your collection. To
        remove subdocuments that are generated by an uploaded file, delete the original
        document instead. You can get the document ID of the original document from the
        `parent_document_id` of the subdocument result.
        If the document with the given document ID exists, Watson Discovery first marks or
        tags the document as deleted when it sends the 200 response code. At a later time
        (within a couple of minutes unless the document has many child documents), it
        removes the document from the collection.
        There is no bulk document delete API. Documents must be deleted one at a time
        using this API. However, you can delete a collection, and all the documents from
        the collection are removed along with the collection.
        The document will be deleted from the given collection only, not from the
        corresponding data source. Wherever relevant, an incremental crawl will not bring
        back the document into Watson Discovery from the data source. Only a full crawl
        will retrieve the deleted document back from the data source provided it is still
        present in the same data source.
        Finally, if multiple collections share the same dataset, deleting a document from
        a collection will remove it from that collection only (in other remaining
        collections the document will still exist). The document will be removed from the
        dataset, if this document is deleted from all the collections that share the same
        dataset.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str document_id: The ID of the document.
        :param bool x_watson_discovery_force: (optional) When `true`, the uploaded
               document is added to the collection even if the data for that collection is
               shared with other collections.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DeleteDocumentResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if not document_id:
            raise ValueError('document_id must be provided')
        headers = {
            'X-Watson-Discovery-Force': x_watson_discovery_force,
        }
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_document',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id', 'document_id']
        path_param_values = self.encode_path_vars(project_id, collection_id,
                                                  document_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/documents/{document_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Queries
    #########################

    def query(
        self,
        project_id: str,
        *,
        collection_ids: Optional[List[str]] = None,
        filter: Optional[str] = None,
        query: Optional[str] = None,
        natural_language_query: Optional[str] = None,
        aggregation: Optional[str] = None,
        count: Optional[int] = None,
        return_: Optional[List[str]] = None,
        offset: Optional[int] = None,
        sort: Optional[str] = None,
        highlight: Optional[bool] = None,
        spelling_suggestions: Optional[bool] = None,
        table_results: Optional['QueryLargeTableResults'] = None,
        suggested_refinements: Optional[
            'QueryLargeSuggestedRefinements'] = None,
        passages: Optional['QueryLargePassages'] = None,
        similar: Optional['QueryLargeSimilar'] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Query a project.

        Search your data by submitting queries that are written in natural language or
        formatted in the Discovery Query Language. For more information, see the
        [Discovery
        documentation](/docs/discovery-data?topic=discovery-data-query-concepts). The
        default query parameters differ by project type. For more information about the
        project default settings, see the [Discovery
        documentation](/docs/discovery-data?topic=discovery-data-query-defaults). See [the
        Projects API documentation](#create-project) for details about how to set custom
        default query settings.
        The length of the UTF-8 encoding of the POST body cannot exceed 10,000 bytes,
        which is roughly equivalent to 10,000 characters in English.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param List[str] collection_ids: (optional) A comma-separated list of
               collection IDs to be queried against.
        :param str filter: (optional) Searches for documents that match the
               Discovery Query Language criteria that is specified as input. Filter calls
               are cached and are faster than query calls because the results are not
               ordered by relevance. When used with the **aggregation**, **query**, or
               **natural_language_query** parameters, the **filter** parameter runs first.
               This parameter is useful for limiting results to those that contain
               specific metadata values.
        :param str query: (optional) A query search that is written in the
               Discovery Query Language and returns all matching documents in your data
               set with full enrichments and full text, and with the most relevant
               documents listed first. Use a query search when you want to find the most
               relevant search results. You can use this parameter or the
               **natural_language_query** parameter to specify the query input, but not
               both.
        :param str natural_language_query: (optional) A natural language query that
               returns relevant documents by using training data and natural language
               understanding. You can use this parameter or the **query** parameter to
               specify the query input, but not both. To filter the results based on
               criteria you specify, include the **filter** parameter in the request.
        :param str aggregation: (optional) An aggregation search that returns an
               exact answer by combining query search with filters. Useful for
               applications to build lists, tables, and time series. For more information
               about the supported types of aggregations, see the [Discovery
               documentation](/docs/discovery-data?topic=discovery-data-query-aggregations).
        :param int count: (optional) Number of results to return.
        :param List[str] return_: (optional) A list of the fields in the document
               hierarchy to return. You can specify both root-level (`text`) and nested
               (`extracted_metadata.filename`) fields. If this parameter is an empty list,
               then all fields are returned.
        :param int offset: (optional) The number of query results to skip at the
               beginning. Consider that the `count` is set to 10 (the default value) and
               the total number of results that are returned is 100. In this case, the
               following examples show the returned results for different `offset` values:
                * If `offset` is set to 95, it returns the last 5 results.
                * If `offset` is set to 10, it returns the second batch of 10 results.
                * If `offset` is set to 100 or more, it returns empty results.
        :param str sort: (optional) A comma-separated list of fields in the
               document to sort on. You can optionally specify a sort direction by
               prefixing the field with `-` for descending or `+` for ascending. Ascending
               is the default sort direction if no prefix is specified.
        :param bool highlight: (optional) When `true`, a highlight field is
               returned for each result that contains fields that match the query. The
               matching query terms are emphasized with surrounding `<em></em>` tags. This
               parameter is ignored if **passages.enabled** and **passages.per_document**
               are `true`, in which case passages are returned for each document instead
               of highlights.
        :param bool spelling_suggestions: (optional) When `true` and the
               **natural_language_query** parameter is used, the
               **natural_language_query** parameter is spell checked. The most likely
               correction is returned in the **suggested_query** field of the response (if
               one exists).
        :param QueryLargeTableResults table_results: (optional) Configuration for
               table retrieval.
        :param QueryLargeSuggestedRefinements suggested_refinements: (optional)
               Configuration for suggested refinements.
               **Note**: The **suggested_refinements** parameter that identified dynamic
               facets from the data is deprecated.
        :param QueryLargePassages passages: (optional) Configuration for passage
               retrieval.
        :param QueryLargeSimilar similar: (optional) Finds results from documents
               that are similar to documents of interest. Use this parameter to add a
               *More like these* function to your search. You can include this parameter
               with or without a **query**, **filter** or **natural_language_query**
               parameter.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `QueryResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if table_results is not None:
            table_results = convert_model(table_results)
        if suggested_refinements is not None:
            suggested_refinements = convert_model(suggested_refinements)
        if passages is not None:
            passages = convert_model(passages)
        if similar is not None:
            similar = convert_model(similar)
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='query',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'collection_ids': collection_ids,
            'filter': filter,
            'query': query,
            'natural_language_query': natural_language_query,
            'aggregation': aggregation,
            'count': count,
            'return': return_,
            'offset': offset,
            'sort': sort,
            'highlight': highlight,
            'spelling_suggestions': spelling_suggestions,
            'table_results': table_results,
            'suggested_refinements': suggested_refinements,
            'passages': passages,
            'similar': similar,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/query'.format(**path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_autocompletion(
        self,
        project_id: str,
        prefix: str,
        *,
        collection_ids: Optional[List[str]] = None,
        field: Optional[str] = None,
        count: Optional[int] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get Autocomplete Suggestions.

        Returns completion query suggestions for the specified prefix.
        Suggested words are based on terms from the project documents. Suggestions are not
        based on terms from the project's search history, and the project does not learn
        from previous user choices.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str prefix: The prefix to use for autocompletion. For example, the
               prefix `Ho` could autocomplete to `hot`, `housing`, or `how`.
        :param List[str] collection_ids: (optional) Comma separated list of the
               collection IDs. If this parameter is not specified, all collections in the
               project are used.
        :param str field: (optional) The field in the result documents that
               autocompletion suggestions are identified from.
        :param int count: (optional) The number of autocompletion suggestions to
               return.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Completions` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not prefix:
            raise ValueError('prefix must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_autocompletion',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'prefix': prefix,
            'collection_ids': convert_list(collection_ids),
            'field': field,
            'count': count,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/autocompletion'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def query_collection_notices(
        self,
        project_id: str,
        collection_id: str,
        *,
        filter: Optional[str] = None,
        query: Optional[str] = None,
        natural_language_query: Optional[str] = None,
        count: Optional[int] = None,
        offset: Optional[int] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Query collection notices.

        Finds collection-level notices (errors and warnings) that are generated when
        documents are ingested.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str filter: (optional) Searches for documents that match the
               Discovery Query Language criteria that is specified as input. Filter calls
               are cached and are faster than query calls because the results are not
               ordered by relevance. When used with the `aggregation`, `query`, or
               `natural_language_query` parameters, the `filter` parameter runs first.
               This parameter is useful for limiting results to those that contain
               specific metadata values.
        :param str query: (optional) A query search that is written in the
               Discovery Query Language and returns all matching documents in your data
               set with full enrichments and full text, and with the most relevant
               documents listed first. You can use this parameter or the
               **natural_language_query** parameter to specify the query input, but not
               both.
        :param str natural_language_query: (optional) A natural language query that
               returns relevant documents by using natural language understanding. You can
               use this parameter or the **query** parameter to specify the query input,
               but not both. To filter the results based on criteria you specify, include
               the **filter** parameter in the request.
        :param int count: (optional) Number of results to return. The maximum for
               the **count** and **offset** values together in any one query is
               **10,000**.
        :param int offset: (optional) The number of query results to skip at the
               beginning. For example, if the total number of results that are returned is
               10 and the offset is 8, it returns the last two results. The maximum for
               the **count** and **offset** values together in any one query is **10000**.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `QueryNoticesResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='query_collection_notices',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'filter': filter,
            'query': query,
            'natural_language_query': natural_language_query,
            'count': count,
            'offset': offset,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/notices'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def query_notices(
        self,
        project_id: str,
        *,
        filter: Optional[str] = None,
        query: Optional[str] = None,
        natural_language_query: Optional[str] = None,
        count: Optional[int] = None,
        offset: Optional[int] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Query project notices.

        Finds project-level notices (errors and warnings). Currently, project-level
        notices are generated by relevancy training.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str filter: (optional) Searches for documents that match the
               Discovery Query Language criteria that is specified as input. Filter calls
               are cached and are faster than query calls because the results are not
               ordered by relevance. When used with the `aggregation`, `query`, or
               `natural_language_query` parameters, the `filter` parameter runs first.
               This parameter is useful for limiting results to those that contain
               specific metadata values.
        :param str query: (optional) A query search that is written in the
               Discovery Query Language and returns all matching documents in your data
               set with full enrichments and full text, and with the most relevant
               documents listed first. You can use this parameter or the
               **natural_language_query** parameter to specify the query input, but not
               both.
        :param str natural_language_query: (optional) A natural language query that
               returns relevant documents by using natural language understanding. You can
               use this parameter or the **query** parameter to specify the query input,
               but not both. To filter the results based on criteria you specify, include
               the **filter** parameter in the request.
        :param int count: (optional) Number of results to return. The maximum for
               the **count** and **offset** values together in any one query is
               **10,000**.
        :param int offset: (optional) The number of query results to skip at the
               beginning. For example, if the total number of results that are returned is
               10 and the offset is 8, it returns the last two results. The maximum for
               the **count** and **offset** values together in any one query is **10000**.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `QueryNoticesResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='query_notices',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'filter': filter,
            'query': query,
            'natural_language_query': natural_language_query,
            'count': count,
            'offset': offset,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/notices'.format(**path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Query modifications
    #########################

    def get_stopword_list(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get a custom stop words list.

        Returns the custom stop words list that is used by the collection. For information
        about the default stop words lists that are applied to queries, see [the product
        documentation](/docs/discovery-data?topic=discovery-data-stopwords).

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `StopWordList` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_stopword_list',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/stopwords'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_stopword_list(
        self,
        project_id: str,
        collection_id: str,
        *,
        stopwords: Optional[List[str]] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create a custom stop words list.

        Adds a list of custom stop words. Stop words are words that you want the service
        to ignore when they occur in a query because they're not useful in distinguishing
        the semantic meaning of the query. The stop words list cannot contain more than 1
        million characters.
        A default stop words list is used by all collections. The default list is applied
        both at indexing time and at query time. A custom stop words list that you add is
        used at query time only.
        The custom stop words list augments the default stop words list; you cannot remove
        stop words. For information about the default stop words lists per language, see
        [the product documentation](/docs/discovery-data?topic=discovery-data-stopwords).

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param List[str] stopwords: (optional) List of stop words.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `StopWordList` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_stopword_list',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'stopwords': stopwords,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/stopwords'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_stopword_list(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a custom stop words list.

        Deletes a custom stop words list to stop using it in queries against the
        collection. After a custom stop words list is deleted, the default stop words list
        is used.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_stopword_list',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/stopwords'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def list_expansions(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get the expansion list.

        Returns the current expansion list for the specified collection. If an expansion
        list is not specified, an empty expansions array is returned.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Expansions` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_expansions',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/expansions'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_expansions(
        self,
        project_id: str,
        collection_id: str,
        expansions: List['Expansion'],
        **kwargs,
    ) -> DetailedResponse:
        """
        Create or update an expansion list.

        Creates or replaces the expansion list for this collection. An expansion list
        introduces alternative wording for key terms that are mentioned in your
        collection. By identifying synonyms or common misspellings, you expand the scope
        of a query beyond exact matches. The maximum number of expanded terms allowed per
        collection is 5,000.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param List[Expansion] expansions: An array of query expansion definitions.
                Each object in the **expansions** array represents a term or set of terms
               that will be expanded into other terms. Each expansion object can be
               configured as `bidirectional` or `unidirectional`.
               * **Bidirectional**: Each entry in the `expanded_terms` list expands to
               include all expanded terms. For example, a query for `ibm` expands to `ibm
               OR international business machines OR big blue`.
               * **Unidirectional**: The terms in `input_terms` in the query are replaced
               by the terms in `expanded_terms`. For example, a query for the often
               misused term `on premise` is converted to `on premises OR on-premises` and
               does not contain the original term. If you want an input term to be
               included in the query, then repeat the input term in the expanded terms
               list.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Expansions` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if expansions is None:
            raise ValueError('expansions must be provided')
        expansions = [convert_model(x) for x in expansions]
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_expansions',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'expansions': expansions,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/expansions'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_expansions(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete the expansion list.

        Removes the expansion information for this collection. To disable query expansion
        for a collection, delete the expansion list.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_expansions',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/expansions'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Component settings
    #########################

    def get_component_settings(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List component settings.

        Returns default configuration settings for components.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ComponentSettingsResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_component_settings',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/component_settings'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Training data
    #########################

    def list_training_queries(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List training queries.

        List the training queries for the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `TrainingQuerySet` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_training_queries',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/training_data/queries'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_training_queries(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete training queries.

        Removes all training queries for the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_training_queries',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/training_data/queries'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_training_query(
        self,
        project_id: str,
        natural_language_query: str,
        examples: List['TrainingExample'],
        *,
        filter: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create a training query.

        Add a query to the training data for this project. The query can contain a filter
        and natural language query.
        **Note**: You cannot apply relevancy training to a `content_mining` project type.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str natural_language_query: The natural text query that is used as
               the training query.
        :param List[TrainingExample] examples: Array of training examples.
        :param str filter: (optional) The filter used on the collection before the
               **natural_language_query** is applied. Only specify a filter if the
               documents that you consider to be most relevant are not included in the top
               100 results when you submit test queries. If you specify a filter during
               training, apply the same filter to queries that are submitted at runtime
               for optimal ranking results.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `TrainingQuery` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if natural_language_query is None:
            raise ValueError('natural_language_query must be provided')
        if examples is None:
            raise ValueError('examples must be provided')
        examples = [convert_model(x) for x in examples]
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_training_query',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'natural_language_query': natural_language_query,
            'examples': examples,
            'filter': filter,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/training_data/queries'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_training_query(
        self,
        project_id: str,
        query_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get a training data query.

        Get details for a specific training data query, including the query string and all
        examples.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str query_id: The ID of the query used for training.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `TrainingQuery` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not query_id:
            raise ValueError('query_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_training_query',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'query_id']
        path_param_values = self.encode_path_vars(project_id, query_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/training_data/queries/{query_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_training_query(
        self,
        project_id: str,
        query_id: str,
        natural_language_query: str,
        examples: List['TrainingExample'],
        *,
        filter: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update a training query.

        Updates an existing training query and its examples. You must resubmit all of the
        examples with the update request.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str query_id: The ID of the query used for training.
        :param str natural_language_query: The natural text query that is used as
               the training query.
        :param List[TrainingExample] examples: Array of training examples.
        :param str filter: (optional) The filter used on the collection before the
               **natural_language_query** is applied. Only specify a filter if the
               documents that you consider to be most relevant are not included in the top
               100 results when you submit test queries. If you specify a filter during
               training, apply the same filter to queries that are submitted at runtime
               for optimal ranking results.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `TrainingQuery` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not query_id:
            raise ValueError('query_id must be provided')
        if natural_language_query is None:
            raise ValueError('natural_language_query must be provided')
        if examples is None:
            raise ValueError('examples must be provided')
        examples = [convert_model(x) for x in examples]
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_training_query',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'natural_language_query': natural_language_query,
            'examples': examples,
            'filter': filter,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'query_id']
        path_param_values = self.encode_path_vars(project_id, query_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/training_data/queries/{query_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_training_query(
        self,
        project_id: str,
        query_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a training data query.

        Removes details from a training data query, including the query string and all
        examples.
        To delete an example, use the *Update a training query* method and omit the
        example that you want to delete from the example set.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str query_id: The ID of the query used for training.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not query_id:
            raise ValueError('query_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_training_query',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'query_id']
        path_param_values = self.encode_path_vars(project_id, query_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/training_data/queries/{query_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Enrichments
    #########################

    def list_enrichments(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List enrichments.

        Lists the enrichments available to this project. The *Part of Speech* and
        *Sentiment of Phrases* enrichments might be listed, but are reserved for internal
        use only.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Enrichments` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_enrichments',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/enrichments'.format(**path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_enrichment(
        self,
        project_id: str,
        enrichment: 'CreateEnrichment',
        *,
        file: Optional[BinaryIO] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create an enrichment.

        Create an enrichment for use with the specified project. To apply the enrichment
        to a collection in the project, use the [Collections
        API](/apidocs/discovery-data#createcollection).

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param CreateEnrichment enrichment: Information about a specific
               enrichment.
        :param BinaryIO file: (optional) The enrichment file to upload. Expected
               file types per enrichment are as follows:
               * CSV for `dictionary` and `sentence_classifier` (the training data CSV
               file to upload).
               * PEAR for `uima_annotator` and `rule_based` (Explorer)
               * ZIP for `watson_knowledge_studio_model` and `rule_based` (Studio Advanced
               Rule Editor).
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Enrichment` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if enrichment is None:
            raise ValueError('enrichment must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_enrichment',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        form_data.append(
            ('enrichment', (None, json.dumps(enrichment), 'application/json')))
        if file:
            form_data.append(('file', (None, file, 'application/octet-stream')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/enrichments'.format(**path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_enrichment(
        self,
        project_id: str,
        enrichment_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get enrichment.

        Get details about a specific enrichment.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str enrichment_id: The Universally Unique Identifier (UUID) of the
               enrichment.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Enrichment` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not enrichment_id:
            raise ValueError('enrichment_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_enrichment',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'enrichment_id']
        path_param_values = self.encode_path_vars(project_id, enrichment_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/enrichments/{enrichment_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_enrichment(
        self,
        project_id: str,
        enrichment_id: str,
        name: str,
        *,
        description: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update an enrichment.

        Updates an existing enrichment's name and description.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str enrichment_id: The Universally Unique Identifier (UUID) of the
               enrichment.
        :param str name: A new name for the enrichment.
        :param str description: (optional) A new description for the enrichment.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `Enrichment` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not enrichment_id:
            raise ValueError('enrichment_id must be provided')
        if name is None:
            raise ValueError('name must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_enrichment',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
            'description': description,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'enrichment_id']
        path_param_values = self.encode_path_vars(project_id, enrichment_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/enrichments/{enrichment_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_enrichment(
        self,
        project_id: str,
        enrichment_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete an enrichment.

        Deletes an existing enrichment from the specified project.
        **Note:** Only enrichments that have been manually created can be deleted.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str enrichment_id: The Universally Unique Identifier (UUID) of the
               enrichment.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not enrichment_id:
            raise ValueError('enrichment_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_enrichment',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'enrichment_id']
        path_param_values = self.encode_path_vars(project_id, enrichment_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/enrichments/{enrichment_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Batches
    #########################

    def list_batches(
        self,
        project_id: str,
        collection_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List batches.

        A batch is a set of documents that are ready for enrichment by an external
        application. After you apply a webhook enrichment to a collection, and then
        process or upload documents to the collection, Discovery creates a batch with a
        unique **batch_id**.
         To start, you must register your external application as a **webhook** type by
        using the [Create enrichment API](/apidocs/discovery-data#createenrichment)
        method.
        Use the List batches API to get the following:
         * Notified batches that are not yet pulled by the external enrichment
        application.
         * Batches that are pulled, but not yet pushed to Discovery by the external
        enrichment application.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `ListBatchesResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_batches',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/batches'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def pull_batches(
        self,
        project_id: str,
        collection_id: str,
        batch_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Pull batches.

        Pull a batch of documents from Discovery for enrichment by an external
        application. Ensure to include the `Accept-Encoding: gzip` header in this method
        to get the file. You can also implement retry logic when calling this method to
        avoid any network errors.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str batch_id: The Universally Unique Identifier (UUID) of the
               document batch that is being requested from Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `PullBatchesResponse` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if not batch_id:
            raise ValueError('batch_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='pull_batches',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id', 'batch_id']
        path_param_values = self.encode_path_vars(project_id, collection_id,
                                                  batch_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/batches/{batch_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def push_batches(
        self,
        project_id: str,
        collection_id: str,
        batch_id: str,
        *,
        file: Optional[BinaryIO] = None,
        filename: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Push batches.

        Push a batch of documents to Discovery after annotation by an external
        application. You can implement retry logic when calling this method to avoid any
        network errors.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param str batch_id: The Universally Unique Identifier (UUID) of the
               document batch that is being requested from Discovery.
        :param BinaryIO file: (optional) A compressed newline-delimited JSON
               (NDJSON), which is a JSON file with one row of data per line. For example,
               `{batch_id}.ndjson.gz`. For more information, see [Binary attachment in the
               push batches
               method](/docs/discovery-data?topic=discovery-data-external-enrichment#binary-attachment-push-batches).
               There is no limitation on the name of the file because Discovery does not
               use the name for processing. The list of features in the document is
               specified in the `features` object.
        :param str filename: (optional) The filename for file.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `bool` result
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        if not batch_id:
            raise ValueError('batch_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='push_batches',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        if file:
            if not filename and hasattr(file, 'name'):
                filename = basename(file.name)
            if not filename:
                raise ValueError('filename must be provided')
            form_data.append(
                ('file', (filename, file, 'application/octet-stream')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id', 'batch_id']
        path_param_values = self.encode_path_vars(project_id, collection_id,
                                                  batch_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/batches/{batch_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Document classifiers
    #########################

    def list_document_classifiers(
        self,
        project_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List document classifiers.

        Get a list of the document classifiers in a project. Returns only the name and
        classifier ID of each document classifier.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifiers` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_document_classifiers',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_document_classifier(
        self,
        project_id: str,
        training_data: BinaryIO,
        classifier: 'CreateDocumentClassifier',
        *,
        test_data: Optional[BinaryIO] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create a document classifier.

        Create a document classifier. You can use the API to create a document classifier
        in any project type. After you create a document classifier, you can use the
        Enrichments API to create a classifier enrichment, and then the Collections API to
        apply the enrichment to a collection in the project.
        **Note:** This method is supported on installed instances (IBM Cloud Pak for Data)
        or IBM Cloud-managed Premium or Enterprise plan instances.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param BinaryIO training_data: The training data CSV file to upload. The
               CSV file must have headers. The file must include a field that contains the
               text you want to classify and a field that contains the classification
               labels that you want to use to classify your data. If you want to specify
               multiple values in a single field, use a semicolon as the value separator.
               For a sample file, see [the product
               documentation](/docs/discovery-data?topic=discovery-data-cm-doc-classifier).
        :param CreateDocumentClassifier classifier: An object that manages the
               settings and data that is required to train a document classification
               model.
        :param BinaryIO test_data: (optional) The CSV with test data to upload. The
               column values in the test file must be the same as the column values in the
               training data file. If no test data is provided, the training data is split
               into two separate groups of training and test data.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifier` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if training_data is None:
            raise ValueError('training_data must be provided')
        if classifier is None:
            raise ValueError('classifier must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_document_classifier',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        form_data.append(('training_data', (None, training_data, 'text/csv')))
        form_data.append(
            ('classifier', (None, json.dumps(classifier), 'application/json')))
        if test_data:
            form_data.append(('test_data', (None, test_data, 'text/csv')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id']
        path_param_values = self.encode_path_vars(project_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_document_classifier(
        self,
        project_id: str,
        classifier_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get a document classifier.

        Get details about a specific document classifier.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifier` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_document_classifier',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'classifier_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_document_classifier(
        self,
        project_id: str,
        classifier_id: str,
        classifier: 'UpdateDocumentClassifier',
        *,
        training_data: Optional[BinaryIO] = None,
        test_data: Optional[BinaryIO] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update a document classifier.

        Update the document classifier name or description, update the training data, or
        add or update the test data.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param UpdateDocumentClassifier classifier: An object that contains a new
               name or description for a document classifier, updated training data, or
               new or updated test data.
        :param BinaryIO training_data: (optional) The training data CSV file to
               upload. The CSV file must have headers. The file must include a field that
               contains the text you want to classify and a field that contains the
               classification labels that you want to use to classify your data. If you
               want to specify multiple values in a single column, use a semicolon as the
               value separator. For a sample file, see [the product
               documentation](/docs/discovery-data?topic=discovery-data-cm-doc-classifier).
        :param BinaryIO test_data: (optional) The CSV with test data to upload. The
               column values in the test file must be the same as the column values in the
               training data file. If no test data is provided, the training data is split
               into two separate groups of training and test data.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifier` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        if classifier is None:
            raise ValueError('classifier must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_document_classifier',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        form_data.append(
            ('classifier', (None, json.dumps(classifier), 'application/json')))
        if training_data:
            form_data.append(
                ('training_data', (None, training_data, 'text/csv')))
        if test_data:
            form_data.append(('test_data', (None, test_data, 'text/csv')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'classifier_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_document_classifier(
        self,
        project_id: str,
        classifier_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a document classifier.

        Deletes an existing document classifier from the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_document_classifier',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'classifier_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Document classifier models
    #########################

    def list_document_classifier_models(
        self,
        project_id: str,
        classifier_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        List document classifier models.

        Get a list of the document classifier models in a project. Returns only the name
        and model ID of each document classifier model.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifierModels` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='list_document_classifier_models',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'classifier_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}/models'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def create_document_classifier_model(
        self,
        project_id: str,
        classifier_id: str,
        name: str,
        *,
        description: Optional[str] = None,
        learning_rate: Optional[float] = None,
        l1_regularization_strengths: Optional[List[float]] = None,
        l2_regularization_strengths: Optional[List[float]] = None,
        training_max_steps: Optional[int] = None,
        improvement_ratio: Optional[float] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Create a document classifier model.

        Create a document classifier model by training a model that uses the data and
        classifier settings defined in the specified document classifier.
        **Note:** This method is supported on installed intances (IBM Cloud Pak for Data)
        or IBM Cloud-managed Premium or Enterprise plan instances.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param str name: The name of the document classifier model.
        :param str description: (optional) A description of the document classifier
               model.
        :param float learning_rate: (optional) A tuning parameter in an
               optimization algorithm that determines the step size at each iteration of
               the training process. It influences how much of any newly acquired
               information overrides the existing information, and therefore is said to
               represent the speed at which a machine learning model learns. The default
               value is `0.1`.
        :param List[float] l1_regularization_strengths: (optional) Avoids
               overfitting by shrinking the coefficient of less important features to
               zero, which removes some features altogether. You can specify many values
               for hyper-parameter optimization. The default value is `[0.000001]`.
        :param List[float] l2_regularization_strengths: (optional) A method you can
               apply to avoid overfitting your model on the training data. You can specify
               many values for hyper-parameter optimization. The default value is
               `[0.000001]`.
        :param int training_max_steps: (optional) Maximum number of training steps
               to complete. This setting is useful if you need the training process to
               finish in a specific time frame to fit into an automated process. The
               default value is ten million.
        :param float improvement_ratio: (optional) Stops the training run early if
               the improvement ratio is not met by the time the process reaches a certain
               point. The default value is `0.00001`.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifierModel` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        if name is None:
            raise ValueError('name must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='create_document_classifier_model',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
            'description': description,
            'learning_rate': learning_rate,
            'l1_regularization_strengths': l1_regularization_strengths,
            'l2_regularization_strengths': l2_regularization_strengths,
            'training_max_steps': training_max_steps,
            'improvement_ratio': improvement_ratio,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'classifier_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}/models'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def get_document_classifier_model(
        self,
        project_id: str,
        classifier_id: str,
        model_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Get a document classifier model.

        Get details about a specific document classifier model.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param str model_id: The Universally Unique Identifier (UUID) of the
               classifier model.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifierModel` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        if not model_id:
            raise ValueError('model_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='get_document_classifier_model',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'classifier_id', 'model_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id,
                                                  model_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}/models/{model_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='GET',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    def update_document_classifier_model(
        self,
        project_id: str,
        classifier_id: str,
        model_id: str,
        *,
        name: Optional[str] = None,
        description: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Update a document classifier model.

        Update the document classifier model name or description.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param str model_id: The Universally Unique Identifier (UUID) of the
               classifier model.
        :param str name: (optional) A new name for the enrichment.
        :param str description: (optional) A new description for the enrichment.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `DocumentClassifierModel` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        if not model_id:
            raise ValueError('model_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='update_document_classifier_model',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        data = {
            'name': name,
            'description': description,
        }
        data = {k: v for (k, v) in data.items() if v is not None}
        data = json.dumps(data)
        headers['content-type'] = 'application/json'

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'classifier_id', 'model_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id,
                                                  model_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}/models/{model_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )

        response = self.send(request, **kwargs)
        return response

    def delete_document_classifier_model(
        self,
        project_id: str,
        classifier_id: str,
        model_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete a document classifier model.

        Deletes an existing document classifier model from the specified project.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str classifier_id: The Universally Unique Identifier (UUID) of the
               classifier.
        :param str model_id: The Universally Unique Identifier (UUID) of the
               classifier model.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not classifier_id:
            raise ValueError('classifier_id must be provided')
        if not model_id:
            raise ValueError('model_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_document_classifier_model',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        path_param_keys = ['project_id', 'classifier_id', 'model_id']
        path_param_values = self.encode_path_vars(project_id, classifier_id,
                                                  model_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/document_classifiers/{classifier_id}/models/{model_id}'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # Analyze
    #########################

    def analyze_document(
        self,
        project_id: str,
        collection_id: str,
        *,
        file: Optional[BinaryIO] = None,
        filename: Optional[str] = None,
        file_content_type: Optional[str] = None,
        metadata: Optional[str] = None,
        **kwargs,
    ) -> DetailedResponse:
        """
        Analyze a document.

        Process a document and return it for realtime use. Supports JSON files only.
        The file is not stored in the collection, but is processed according to the
        collection's configuration settings. To get results, enrichments must be applied
        to a field in the collection that also exists in the file that you want to
        analyze. For example, to analyze text in a `Quote` field, you must apply
        enrichments to the `Quote` field in the collection configuration. Then, when you
        analyze the file, the text in the `Quote` field is analyzed and results are
        written to a field named `enriched_Quote`.
        Submit a request against only one collection at a time. Remember, the documents in
        the collection are not significant. It is the enrichments that are defined for the
        collection that matter. If you submit requests to several collections, then
        several models are initiated at the same time, which can cause request failures.
        **Note:** This method is supported with Enterprise plan deployments and installed
        deployments only.

        :param str project_id: The Universally Unique Identifier (UUID) of the
               project. This information can be found from the *Integrate and Deploy* page
               in Discovery.
        :param str collection_id: The Universally Unique Identifier (UUID) of the
               collection.
        :param BinaryIO file: (optional) **Add a document**: The content of the
               document to ingest. For the supported file types and maximum supported file
               size limits when adding a document, see [the
               documentation](/docs/discovery-data?topic=discovery-data-collections#supportedfiletypes).
               **Analyze a document**: The content of the document to analyze but not
               ingest. Only the `application/json` content type is supported by the
               Analyze API. For maximum supported file size limits, see [the product
               documentation](/docs/discovery-data?topic=discovery-data-analyzeapi#analyzeapi-limits).
        :param str filename: (optional) The filename for file.
        :param str file_content_type: (optional) The content type of file.
        :param str metadata: (optional) Add information about the file that you
               want to include in the response.
               The maximum supported metadata file size is 1 MB. Metadata parts larger
               than 1 MB are rejected.
               Example:
                ```
                {
                 "filename": "favorites2.json",
                 "file_type": "json"
                }.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse with `dict` result representing a `AnalyzedDocument` object
        """

        if not project_id:
            raise ValueError('project_id must be provided')
        if not collection_id:
            raise ValueError('collection_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='analyze_document',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
        }

        form_data = []
        if file:
            if not filename and hasattr(file, 'name'):
                filename = basename(file.name)
            if not filename:
                raise ValueError('filename must be provided')
            form_data.append(('file', (filename, file, file_content_type or
                                       'application/octet-stream')))
        if metadata:
            form_data.append(('metadata', (None, metadata, 'text/plain')))

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']
        headers['Accept'] = 'application/json'

        path_param_keys = ['project_id', 'collection_id']
        path_param_values = self.encode_path_vars(project_id, collection_id)
        path_param_dict = dict(zip(path_param_keys, path_param_values))
        url = '/v2/projects/{project_id}/collections/{collection_id}/analyze'.format(
            **path_param_dict)
        request = self.prepare_request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            files=form_data,
        )

        response = self.send(request, **kwargs)
        return response

    #########################
    # User data
    #########################

    def delete_user_data(
        self,
        customer_id: str,
        **kwargs,
    ) -> DetailedResponse:
        """
        Delete labeled data.

        Deletes all data associated with a specified customer ID. The method has no effect
        if no data is associated with the customer ID.
        You associate a customer ID with data by passing the **X-Watson-Metadata** header
        with a request that passes data. For more information about personal data and
        customer IDs, see [Information
        security](/docs/discovery-data?topic=discovery-data-information-security#information-security).
        **Note:** This method is only supported on IBM Cloud instances of Discovery.

        :param str customer_id: The customer ID for which all data is to be
               deleted.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if not customer_id:
            raise ValueError('customer_id must be provided')
        headers = {}
        sdk_headers = get_sdk_headers(
            service_name=self.DEFAULT_SERVICE_NAME,
            service_version='V2',
            operation_id='delete_user_data',
        )
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'customer_id': customer_id,
        }

        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
            del kwargs['headers']

        url = '/v2/user_data'
        request = self.prepare_request(
            method='DELETE',
            url=url,
            headers=headers,
            params=params,
        )

        response = self.send(request, **kwargs)
        return response


class AddDocumentEnums:
    """
    Enums for add_document parameters.
    """

    class FileContentType(str, Enum):
        """
        The content type of file.
        """

        APPLICATION_JSON = 'application/json'
        APPLICATION_MSWORD = 'application/msword'
        APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_WORDPROCESSINGML_DOCUMENT = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
        APPLICATION_PDF = 'application/pdf'
        TEXT_HTML = 'text/html'
        APPLICATION_XHTML_XML = 'application/xhtml+xml'


class UpdateDocumentEnums:
    """
    Enums for update_document parameters.
    """

    class FileContentType(str, Enum):
        """
        The content type of file.
        """

        APPLICATION_JSON = 'application/json'
        APPLICATION_MSWORD = 'application/msword'
        APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_WORDPROCESSINGML_DOCUMENT = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
        APPLICATION_PDF = 'application/pdf'
        TEXT_HTML = 'text/html'
        APPLICATION_XHTML_XML = 'application/xhtml+xml'


class AnalyzeDocumentEnums:
    """
    Enums for analyze_document parameters.
    """

    class FileContentType(str, Enum):
        """
        The content type of file.
        """

        APPLICATION_JSON = 'application/json'
        APPLICATION_MSWORD = 'application/msword'
        APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_WORDPROCESSINGML_DOCUMENT = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
        APPLICATION_PDF = 'application/pdf'
        TEXT_HTML = 'text/html'
        APPLICATION_XHTML_XML = 'application/xhtml+xml'


##############################################################################
# Models
##############################################################################


class AnalyzedDocument:
    """
    An object that contains the converted document and any identified enrichments.
    Root-level fields from the original file are returned also.

    :param List[Notice] notices: (optional) Array of notices that are triggered when
          the files are processed.
    :param AnalyzedResult result: (optional) Result of the document analysis.
    """

    def __init__(
        self,
        *,
        notices: Optional[List['Notice']] = None,
        result: Optional['AnalyzedResult'] = None,
    ) -> None:
        """
        Initialize a AnalyzedDocument object.

        :param List[Notice] notices: (optional) Array of notices that are triggered
               when the files are processed.
        :param AnalyzedResult result: (optional) Result of the document analysis.
        """
        self.notices = notices
        self.result = result

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'AnalyzedDocument':
        """Initialize a AnalyzedDocument object from a json dictionary."""
        args = {}
        if (notices := _dict.get('notices')) is not None:
            args['notices'] = [Notice.from_dict(v) for v in notices]
        if (result := _dict.get('result')) is not None:
            args['result'] = AnalyzedResult.from_dict(result)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a AnalyzedDocument object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'notices') and self.notices is not None:
            notices_list = []
            for v in self.notices:
                if isinstance(v, dict):
                    notices_list.append(v)
                else:
                    notices_list.append(v.to_dict())
            _dict['notices'] = notices_list
        if hasattr(self, 'result') and self.result is not None:
            if isinstance(self.result, dict):
                _dict['result'] = self.result
            else:
                _dict['result'] = self.result.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this AnalyzedDocument object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'AnalyzedDocument') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'AnalyzedDocument') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class AnalyzedResult:
    """
    Result of the document analysis.

    :param dict metadata: (optional) Metadata that was specified with the request.

    This type supports additional properties of type object. The remaining key-value
    pairs.
    """

    # The set of defined properties for the class
    _properties = frozenset(['metadata'])

    def __init__(
        self,
        *,
        metadata: Optional[dict] = None,
        **kwargs: Optional[object],
    ) -> None:
        """
        Initialize a AnalyzedResult object.

        :param dict metadata: (optional) Metadata that was specified with the
               request.
        :param object **kwargs: (optional) The remaining key-value pairs.
        """
        self.metadata = metadata
        for k, v in kwargs.items():
            if k not in AnalyzedResult._properties:
                if not isinstance(v, object):
                    raise ValueError(
                        'Value for additional property {} must be of type object'
                        .format(k))
                setattr(self, k, v)
            else:
                raise ValueError(
                    'Property {} cannot be specified as an additional property'.
                    format(k))

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'AnalyzedResult':
        """Initialize a AnalyzedResult object from a json dictionary."""
        args = {}
        if (metadata := _dict.get('metadata')) is not None:
            args['metadata'] = metadata
        for k, v in _dict.items():
            if k not in cls._properties:
                if not isinstance(v, object):
                    raise ValueError(
                        'Value for additional property {} must be of type object'
                        .format(k))
                args[k] = v
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a AnalyzedResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'metadata') and self.metadata is not None:
            _dict['metadata'] = self.metadata
        for k in [
                _k for _k in vars(self).keys()
                if _k not in AnalyzedResult._properties
        ]:
            _dict[k] = getattr(self, k)
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def get_properties(self) -> Dict:
        """Return the additional properties from this instance of AnalyzedResult in the form of a dict."""
        _dict = {}
        for k in [
                _k for _k in vars(self).keys()
                if _k not in AnalyzedResult._properties
        ]:
            _dict[k] = getattr(self, k)
        return _dict

    def set_properties(self, _dict: dict):
        """Set a dictionary of additional properties in this instance of AnalyzedResult"""
        for k in [
                _k for _k in vars(self).keys()
                if _k not in AnalyzedResult._properties
        ]:
            delattr(self, k)
        for k, v in _dict.items():
            if k not in AnalyzedResult._properties:
                if not isinstance(v, object):
                    raise ValueError(
                        'Value for additional property {} must be of type object'
                        .format(k))
                setattr(self, k, v)
            else:
                raise ValueError(
                    'Property {} cannot be specified as an additional property'.
                    format(k))

    def __str__(self) -> str:
        """Return a `str` version of this AnalyzedResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'AnalyzedResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'AnalyzedResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class BatchDetails:
    """
    A batch is a set of documents that are ready for enrichment by an external
    application. After you apply a webhook enrichment to a collection, and then process or
    upload documents to the collection, Discovery creates a batch with a unique
    **batch_id**.

    :param str batch_id: (optional) The Universally Unique Identifier (UUID) for a
          batch of documents.
    :param datetime created: (optional) The date and time (RFC3339) that the batch
          was created.
    :param str enrichment_id: (optional) The Universally Unique Identifier (UUID)
          for the external enrichment.
    """

    def __init__(
        self,
        *,
        batch_id: Optional[str] = None,
        created: Optional[datetime] = None,
        enrichment_id: Optional[str] = None,
    ) -> None:
        """
        Initialize a BatchDetails object.

        :param str enrichment_id: (optional) The Universally Unique Identifier
               (UUID) for the external enrichment.
        """
        self.batch_id = batch_id
        self.created = created
        self.enrichment_id = enrichment_id

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'BatchDetails':
        """Initialize a BatchDetails object from a json dictionary."""
        args = {}
        if (batch_id := _dict.get('batch_id')) is not None:
            args['batch_id'] = batch_id
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (enrichment_id := _dict.get('enrichment_id')) is not None:
            args['enrichment_id'] = enrichment_id
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a BatchDetails object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'batch_id') and getattr(self, 'batch_id') is not None:
            _dict['batch_id'] = getattr(self, 'batch_id')
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'enrichment_id') and self.enrichment_id is not None:
            _dict['enrichment_id'] = self.enrichment_id
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this BatchDetails object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'BatchDetails') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'BatchDetails') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ClassifierFederatedModel:
    """
    An object with details for creating federated document classifier models.

    :param str field: Name of the field that contains the values from which multiple
          classifier models are defined. For example, you can specify a field that lists
          product lines to create a separate model per product line.
    """

    def __init__(
        self,
        field: str,
    ) -> None:
        """
        Initialize a ClassifierFederatedModel object.

        :param str field: Name of the field that contains the values from which
               multiple classifier models are defined. For example, you can specify a
               field that lists product lines to create a separate model per product line.
        """
        self.field = field

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ClassifierFederatedModel':
        """Initialize a ClassifierFederatedModel object from a json dictionary."""
        args = {}
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        else:
            raise ValueError(
                'Required property \'field\' not present in ClassifierFederatedModel JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ClassifierFederatedModel object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ClassifierFederatedModel object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ClassifierFederatedModel') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ClassifierFederatedModel') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ClassifierModelEvaluation:
    """
    An object that contains information about a trained document classifier model.

    :param ModelEvaluationMicroAverage micro_average: A micro-average aggregates the
          contributions of all classes to compute the average metric. Classes refers to
          the classification labels that are specified in the **answer_field**.
    :param ModelEvaluationMacroAverage macro_average: A macro-average computes
          metric independently for each class and then takes the average. Class refers to
          the classification label that is specified in the **answer_field**.
    :param List[PerClassModelEvaluation] per_class: An array of evaluation metrics,
          one set of metrics for each class, where class refers to the classification
          label that is specified in the **answer_field**.
    """

    def __init__(
        self,
        micro_average: 'ModelEvaluationMicroAverage',
        macro_average: 'ModelEvaluationMacroAverage',
        per_class: List['PerClassModelEvaluation'],
    ) -> None:
        """
        Initialize a ClassifierModelEvaluation object.

        :param ModelEvaluationMicroAverage micro_average: A micro-average
               aggregates the contributions of all classes to compute the average metric.
               Classes refers to the classification labels that are specified in the
               **answer_field**.
        :param ModelEvaluationMacroAverage macro_average: A macro-average computes
               metric independently for each class and then takes the average. Class
               refers to the classification label that is specified in the
               **answer_field**.
        :param List[PerClassModelEvaluation] per_class: An array of evaluation
               metrics, one set of metrics for each class, where class refers to the
               classification label that is specified in the **answer_field**.
        """
        self.micro_average = micro_average
        self.macro_average = macro_average
        self.per_class = per_class

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ClassifierModelEvaluation':
        """Initialize a ClassifierModelEvaluation object from a json dictionary."""
        args = {}
        if (micro_average := _dict.get('micro_average')) is not None:
            args['micro_average'] = ModelEvaluationMicroAverage.from_dict(
                micro_average)
        else:
            raise ValueError(
                'Required property \'micro_average\' not present in ClassifierModelEvaluation JSON'
            )
        if (macro_average := _dict.get('macro_average')) is not None:
            args['macro_average'] = ModelEvaluationMacroAverage.from_dict(
                macro_average)
        else:
            raise ValueError(
                'Required property \'macro_average\' not present in ClassifierModelEvaluation JSON'
            )
        if (per_class := _dict.get('per_class')) is not None:
            args['per_class'] = [
                PerClassModelEvaluation.from_dict(v) for v in per_class
            ]
        else:
            raise ValueError(
                'Required property \'per_class\' not present in ClassifierModelEvaluation JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ClassifierModelEvaluation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'micro_average') and self.micro_average is not None:
            if isinstance(self.micro_average, dict):
                _dict['micro_average'] = self.micro_average
            else:
                _dict['micro_average'] = self.micro_average.to_dict()
        if hasattr(self, 'macro_average') and self.macro_average is not None:
            if isinstance(self.macro_average, dict):
                _dict['macro_average'] = self.macro_average
            else:
                _dict['macro_average'] = self.macro_average.to_dict()
        if hasattr(self, 'per_class') and self.per_class is not None:
            per_class_list = []
            for v in self.per_class:
                if isinstance(v, dict):
                    per_class_list.append(v)
                else:
                    per_class_list.append(v.to_dict())
            _dict['per_class'] = per_class_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ClassifierModelEvaluation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ClassifierModelEvaluation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ClassifierModelEvaluation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Collection:
    """
    A collection for storing documents.

    :param str collection_id: (optional) The Universally Unique Identifier (UUID) of
          the collection.
    :param str name: (optional) The name of the collection.
    """

    def __init__(
        self,
        *,
        collection_id: Optional[str] = None,
        name: Optional[str] = None,
    ) -> None:
        """
        Initialize a Collection object.

        :param str name: (optional) The name of the collection.
        """
        self.collection_id = collection_id
        self.name = name

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Collection':
        """Initialize a Collection object from a json dictionary."""
        args = {}
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Collection object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'collection_id') and getattr(
                self, 'collection_id') is not None:
            _dict['collection_id'] = getattr(self, 'collection_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Collection object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Collection') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Collection') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class CollectionDetails:
    """
    A collection for storing documents.

    :param str collection_id: (optional) The Universally Unique Identifier (UUID) of
          the collection.
    :param str name: The name of the collection.
    :param str description: (optional) A description of the collection.
    :param datetime created: (optional) The date that the collection was created.
    :param str language: (optional) The language of the collection. For a list of
          supported languages, see the [product
          documentation](/docs/discovery-data?topic=discovery-data-language-support).
    :param bool ocr_enabled: (optional) If set to `true`, optical character
          recognition (OCR) is enabled. For more information, see [Optical character
          recognition](/docs/discovery-data?topic=discovery-data-collections#ocr).
    :param List[CollectionEnrichment] enrichments: (optional) An array of
          enrichments that are applied to this collection. To get a list of enrichments
          that are available for a project, use the [List enrichments](#listenrichments)
          method.
          If no enrichments are specified when the collection is created, the default
          enrichments for the project type are applied. For more information about project
          default settings, see the [product
          documentation](/docs/discovery-data?topic=discovery-data-project-defaults).
    :param CollectionDetailsSmartDocumentUnderstanding smart_document_understanding:
          (optional) An object that describes the Smart Document Understanding model for a
          collection.
    """

    def __init__(
        self,
        name: str,
        *,
        collection_id: Optional[str] = None,
        description: Optional[str] = None,
        created: Optional[datetime] = None,
        language: Optional[str] = None,
        ocr_enabled: Optional[bool] = None,
        enrichments: Optional[List['CollectionEnrichment']] = None,
        smart_document_understanding: Optional[
            'CollectionDetailsSmartDocumentUnderstanding'] = None,
    ) -> None:
        """
        Initialize a CollectionDetails object.

        :param str name: The name of the collection.
        :param str description: (optional) A description of the collection.
        :param str language: (optional) The language of the collection. For a list
               of supported languages, see the [product
               documentation](/docs/discovery-data?topic=discovery-data-language-support).
        :param bool ocr_enabled: (optional) If set to `true`, optical character
               recognition (OCR) is enabled. For more information, see [Optical character
               recognition](/docs/discovery-data?topic=discovery-data-collections#ocr).
        :param List[CollectionEnrichment] enrichments: (optional) An array of
               enrichments that are applied to this collection. To get a list of
               enrichments that are available for a project, use the [List
               enrichments](#listenrichments) method.
               If no enrichments are specified when the collection is created, the default
               enrichments for the project type are applied. For more information about
               project default settings, see the [product
               documentation](/docs/discovery-data?topic=discovery-data-project-defaults).
        """
        self.collection_id = collection_id
        self.name = name
        self.description = description
        self.created = created
        self.language = language
        self.ocr_enabled = ocr_enabled
        self.enrichments = enrichments
        self.smart_document_understanding = smart_document_understanding

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'CollectionDetails':
        """Initialize a CollectionDetails object from a json dictionary."""
        args = {}
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        else:
            raise ValueError(
                'Required property \'name\' not present in CollectionDetails JSON'
            )
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (language := _dict.get('language')) is not None:
            args['language'] = language
        if (ocr_enabled := _dict.get('ocr_enabled')) is not None:
            args['ocr_enabled'] = ocr_enabled
        if (enrichments := _dict.get('enrichments')) is not None:
            args['enrichments'] = [
                CollectionEnrichment.from_dict(v) for v in enrichments
            ]
        if (smart_document_understanding :=
                _dict.get('smart_document_understanding')) is not None:
            args[
                'smart_document_understanding'] = CollectionDetailsSmartDocumentUnderstanding.from_dict(
                    smart_document_understanding)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a CollectionDetails object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'collection_id') and getattr(
                self, 'collection_id') is not None:
            _dict['collection_id'] = getattr(self, 'collection_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'language') and self.language is not None:
            _dict['language'] = self.language
        if hasattr(self, 'ocr_enabled') and self.ocr_enabled is not None:
            _dict['ocr_enabled'] = self.ocr_enabled
        if hasattr(self, 'enrichments') and self.enrichments is not None:
            enrichments_list = []
            for v in self.enrichments:
                if isinstance(v, dict):
                    enrichments_list.append(v)
                else:
                    enrichments_list.append(v.to_dict())
            _dict['enrichments'] = enrichments_list
        if hasattr(self, 'smart_document_understanding') and getattr(
                self, 'smart_document_understanding') is not None:
            if isinstance(getattr(self, 'smart_document_understanding'), dict):
                _dict['smart_document_understanding'] = getattr(
                    self, 'smart_document_understanding')
            else:
                _dict['smart_document_understanding'] = getattr(
                    self, 'smart_document_understanding').to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this CollectionDetails object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'CollectionDetails') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'CollectionDetails') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class CollectionDetailsSmartDocumentUnderstanding:
    """
    An object that describes the Smart Document Understanding model for a collection.

    :param bool enabled: (optional) When `true`, smart document understanding
          conversion is enabled for the collection.
    :param str model: (optional) Specifies the type of Smart Document Understanding
          (SDU) model that is enabled for the collection. The following types of models
          are supported:
           * `custom`: A user-trained model is applied.
           * `pre_trained`: A pretrained model is applied. This type of model is applied
          automatically to *Document Retrieval for Contracts* projects.
           * `text_extraction`: An SDU model that extracts text and metadata from the
          content. This model is enabled in collections by default regardless of the types
          of documents in the collection (as long as the service plan supports SDU
          models).
          You can apply user-trained or pretrained models to collections from the
          *Identify fields* page of the product user interface. For more information, see
          [the product
          documentation](/docs/discovery-data?topic=discovery-data-configuring-fields).
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        model: Optional[str] = None,
    ) -> None:
        """
        Initialize a CollectionDetailsSmartDocumentUnderstanding object.

        :param bool enabled: (optional) When `true`, smart document understanding
               conversion is enabled for the collection.
        :param str model: (optional) Specifies the type of Smart Document
               Understanding (SDU) model that is enabled for the collection. The following
               types of models are supported:
                * `custom`: A user-trained model is applied.
                * `pre_trained`: A pretrained model is applied. This type of model is
               applied automatically to *Document Retrieval for Contracts* projects.
                * `text_extraction`: An SDU model that extracts text and metadata from the
               content. This model is enabled in collections by default regardless of the
               types of documents in the collection (as long as the service plan supports
               SDU models).
               You can apply user-trained or pretrained models to collections from the
               *Identify fields* page of the product user interface. For more information,
               see [the product
               documentation](/docs/discovery-data?topic=discovery-data-configuring-fields).
        """
        self.enabled = enabled
        self.model = model

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'CollectionDetailsSmartDocumentUnderstanding':
        """Initialize a CollectionDetailsSmartDocumentUnderstanding object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (model := _dict.get('model')) is not None:
            args['model'] = model
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a CollectionDetailsSmartDocumentUnderstanding object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'model') and self.model is not None:
            _dict['model'] = self.model
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this CollectionDetailsSmartDocumentUnderstanding object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self,
               other: 'CollectionDetailsSmartDocumentUnderstanding') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self,
               other: 'CollectionDetailsSmartDocumentUnderstanding') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class ModelEnum(str, Enum):
        """
        Specifies the type of Smart Document Understanding (SDU) model that is enabled for
        the collection. The following types of models are supported:
         * `custom`: A user-trained model is applied.
         * `pre_trained`: A pretrained model is applied. This type of model is applied
        automatically to *Document Retrieval for Contracts* projects.
         * `text_extraction`: An SDU model that extracts text and metadata from the
        content. This model is enabled in collections by default regardless of the types
        of documents in the collection (as long as the service plan supports SDU models).
        You can apply user-trained or pretrained models to collections from the *Identify
        fields* page of the product user interface. For more information, see [the product
        documentation](/docs/discovery-data?topic=discovery-data-configuring-fields).
        """

        CUSTOM = 'custom'
        PRE_TRAINED = 'pre_trained'
        TEXT_EXTRACTION = 'text_extraction'


class CollectionEnrichment:
    """
    An object describing an enrichment for a collection.

    :param str enrichment_id: (optional) The unique identifier of this enrichment.
          For more information about how to determine the ID of an enrichment, see [the
          product
          documentation](/docs/discovery-data?topic=discovery-data-manage-enrichments#enrichments-ids).
    :param List[str] fields: (optional) An array of field names that the enrichment
          is applied to.
          If you apply an enrichment to a field from a JSON file, the data is converted to
          an array automatically, even if the field contains a single value.
    """

    def __init__(
        self,
        *,
        enrichment_id: Optional[str] = None,
        fields: Optional[List[str]] = None,
    ) -> None:
        """
        Initialize a CollectionEnrichment object.

        :param str enrichment_id: (optional) The unique identifier of this
               enrichment. For more information about how to determine the ID of an
               enrichment, see [the product
               documentation](/docs/discovery-data?topic=discovery-data-manage-enrichments#enrichments-ids).
        :param List[str] fields: (optional) An array of field names that the
               enrichment is applied to.
               If you apply an enrichment to a field from a JSON file, the data is
               converted to an array automatically, even if the field contains a single
               value.
        """
        self.enrichment_id = enrichment_id
        self.fields = fields

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'CollectionEnrichment':
        """Initialize a CollectionEnrichment object from a json dictionary."""
        args = {}
        if (enrichment_id := _dict.get('enrichment_id')) is not None:
            args['enrichment_id'] = enrichment_id
        if (fields := _dict.get('fields')) is not None:
            args['fields'] = fields
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a CollectionEnrichment object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enrichment_id') and self.enrichment_id is not None:
            _dict['enrichment_id'] = self.enrichment_id
        if hasattr(self, 'fields') and self.fields is not None:
            _dict['fields'] = self.fields
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this CollectionEnrichment object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'CollectionEnrichment') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'CollectionEnrichment') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Completions:
    """
    An object that contains an array of autocompletion suggestions.

    :param List[str] completions: (optional) Array of autocomplete suggestion based
          on the provided prefix.
    """

    def __init__(
        self,
        *,
        completions: Optional[List[str]] = None,
    ) -> None:
        """
        Initialize a Completions object.

        :param List[str] completions: (optional) Array of autocomplete suggestion
               based on the provided prefix.
        """
        self.completions = completions

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Completions':
        """Initialize a Completions object from a json dictionary."""
        args = {}
        if (completions := _dict.get('completions')) is not None:
            args['completions'] = completions
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Completions object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'completions') and self.completions is not None:
            _dict['completions'] = self.completions
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Completions object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Completions') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Completions') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ComponentSettingsAggregation:
    """
    Display settings for aggregations.

    :param str name: (optional) Identifier used to map aggregation settings to
          aggregation configuration.
    :param str label: (optional) User-friendly alias for the aggregation.
    :param bool multiple_selections_allowed: (optional) Whether users is allowed to
          select more than one of the aggregation terms.
    :param str visualization_type: (optional) Type of visualization to use when
          rendering the aggregation.
    """

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        label: Optional[str] = None,
        multiple_selections_allowed: Optional[bool] = None,
        visualization_type: Optional[str] = None,
    ) -> None:
        """
        Initialize a ComponentSettingsAggregation object.

        :param str name: (optional) Identifier used to map aggregation settings to
               aggregation configuration.
        :param str label: (optional) User-friendly alias for the aggregation.
        :param bool multiple_selections_allowed: (optional) Whether users is
               allowed to select more than one of the aggregation terms.
        :param str visualization_type: (optional) Type of visualization to use when
               rendering the aggregation.
        """
        self.name = name
        self.label = label
        self.multiple_selections_allowed = multiple_selections_allowed
        self.visualization_type = visualization_type

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ComponentSettingsAggregation':
        """Initialize a ComponentSettingsAggregation object from a json dictionary."""
        args = {}
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (label := _dict.get('label')) is not None:
            args['label'] = label
        if (multiple_selections_allowed :=
                _dict.get('multiple_selections_allowed')) is not None:
            args['multiple_selections_allowed'] = multiple_selections_allowed
        if (visualization_type := _dict.get('visualization_type')) is not None:
            args['visualization_type'] = visualization_type
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ComponentSettingsAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'label') and self.label is not None:
            _dict['label'] = self.label
        if hasattr(self, 'multiple_selections_allowed'
                  ) and self.multiple_selections_allowed is not None:
            _dict[
                'multiple_selections_allowed'] = self.multiple_selections_allowed
        if hasattr(
                self,
                'visualization_type') and self.visualization_type is not None:
            _dict['visualization_type'] = self.visualization_type
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ComponentSettingsAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ComponentSettingsAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ComponentSettingsAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class VisualizationTypeEnum(str, Enum):
        """
        Type of visualization to use when rendering the aggregation.
        """

        AUTO = 'auto'
        FACET_TABLE = 'facet_table'
        WORD_CLOUD = 'word_cloud'
        MAP = 'map'


class ComponentSettingsFieldsShown:
    """
    Fields shown in the results section of the UI.

    :param ComponentSettingsFieldsShownBody body: (optional) Body label.
    :param ComponentSettingsFieldsShownTitle title: (optional) Title label.
    """

    def __init__(
        self,
        *,
        body: Optional['ComponentSettingsFieldsShownBody'] = None,
        title: Optional['ComponentSettingsFieldsShownTitle'] = None,
    ) -> None:
        """
        Initialize a ComponentSettingsFieldsShown object.

        :param ComponentSettingsFieldsShownBody body: (optional) Body label.
        :param ComponentSettingsFieldsShownTitle title: (optional) Title label.
        """
        self.body = body
        self.title = title

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ComponentSettingsFieldsShown':
        """Initialize a ComponentSettingsFieldsShown object from a json dictionary."""
        args = {}
        if (body := _dict.get('body')) is not None:
            args['body'] = ComponentSettingsFieldsShownBody.from_dict(body)
        if (title := _dict.get('title')) is not None:
            args['title'] = ComponentSettingsFieldsShownTitle.from_dict(title)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ComponentSettingsFieldsShown object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'body') and self.body is not None:
            if isinstance(self.body, dict):
                _dict['body'] = self.body
            else:
                _dict['body'] = self.body.to_dict()
        if hasattr(self, 'title') and self.title is not None:
            if isinstance(self.title, dict):
                _dict['title'] = self.title
            else:
                _dict['title'] = self.title.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ComponentSettingsFieldsShown object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ComponentSettingsFieldsShown') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ComponentSettingsFieldsShown') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ComponentSettingsFieldsShownBody:
    """
    Body label.

    :param bool use_passage: (optional) Use the whole passage as the body.
    :param str field: (optional) Use a specific field as the title.
    """

    def __init__(
        self,
        *,
        use_passage: Optional[bool] = None,
        field: Optional[str] = None,
    ) -> None:
        """
        Initialize a ComponentSettingsFieldsShownBody object.

        :param bool use_passage: (optional) Use the whole passage as the body.
        :param str field: (optional) Use a specific field as the title.
        """
        self.use_passage = use_passage
        self.field = field

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ComponentSettingsFieldsShownBody':
        """Initialize a ComponentSettingsFieldsShownBody object from a json dictionary."""
        args = {}
        if (use_passage := _dict.get('use_passage')) is not None:
            args['use_passage'] = use_passage
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ComponentSettingsFieldsShownBody object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'use_passage') and self.use_passage is not None:
            _dict['use_passage'] = self.use_passage
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ComponentSettingsFieldsShownBody object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ComponentSettingsFieldsShownBody') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ComponentSettingsFieldsShownBody') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ComponentSettingsFieldsShownTitle:
    """
    Title label.

    :param str field: (optional) Use a specific field as the title.
    """

    def __init__(
        self,
        *,
        field: Optional[str] = None,
    ) -> None:
        """
        Initialize a ComponentSettingsFieldsShownTitle object.

        :param str field: (optional) Use a specific field as the title.
        """
        self.field = field

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ComponentSettingsFieldsShownTitle':
        """Initialize a ComponentSettingsFieldsShownTitle object from a json dictionary."""
        args = {}
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ComponentSettingsFieldsShownTitle object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ComponentSettingsFieldsShownTitle object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ComponentSettingsFieldsShownTitle') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ComponentSettingsFieldsShownTitle') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ComponentSettingsResponse:
    """
    The default component settings for this project.

    :param ComponentSettingsFieldsShown fields_shown: (optional) Fields shown in the
          results section of the UI.
    :param bool autocomplete: (optional) Whether or not autocomplete is enabled.
    :param bool structured_search: (optional) Whether or not structured search is
          enabled.
    :param int results_per_page: (optional) Number or results shown per page.
    :param List[ComponentSettingsAggregation] aggregations: (optional) a list of
          component setting aggregations.
    """

    def __init__(
        self,
        *,
        fields_shown: Optional['ComponentSettingsFieldsShown'] = None,
        autocomplete: Optional[bool] = None,
        structured_search: Optional[bool] = None,
        results_per_page: Optional[int] = None,
        aggregations: Optional[List['ComponentSettingsAggregation']] = None,
    ) -> None:
        """
        Initialize a ComponentSettingsResponse object.

        :param ComponentSettingsFieldsShown fields_shown: (optional) Fields shown
               in the results section of the UI.
        :param bool autocomplete: (optional) Whether or not autocomplete is
               enabled.
        :param bool structured_search: (optional) Whether or not structured search
               is enabled.
        :param int results_per_page: (optional) Number or results shown per page.
        :param List[ComponentSettingsAggregation] aggregations: (optional) a list
               of component setting aggregations.
        """
        self.fields_shown = fields_shown
        self.autocomplete = autocomplete
        self.structured_search = structured_search
        self.results_per_page = results_per_page
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ComponentSettingsResponse':
        """Initialize a ComponentSettingsResponse object from a json dictionary."""
        args = {}
        if (fields_shown := _dict.get('fields_shown')) is not None:
            args['fields_shown'] = ComponentSettingsFieldsShown.from_dict(
                fields_shown)
        if (autocomplete := _dict.get('autocomplete')) is not None:
            args['autocomplete'] = autocomplete
        if (structured_search := _dict.get('structured_search')) is not None:
            args['structured_search'] = structured_search
        if (results_per_page := _dict.get('results_per_page')) is not None:
            args['results_per_page'] = results_per_page
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = [
                ComponentSettingsAggregation.from_dict(v) for v in aggregations
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ComponentSettingsResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'fields_shown') and self.fields_shown is not None:
            if isinstance(self.fields_shown, dict):
                _dict['fields_shown'] = self.fields_shown
            else:
                _dict['fields_shown'] = self.fields_shown.to_dict()
        if hasattr(self, 'autocomplete') and self.autocomplete is not None:
            _dict['autocomplete'] = self.autocomplete
        if hasattr(self,
                   'structured_search') and self.structured_search is not None:
            _dict['structured_search'] = self.structured_search
        if hasattr(self,
                   'results_per_page') and self.results_per_page is not None:
            _dict['results_per_page'] = self.results_per_page
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            aggregations_list = []
            for v in self.aggregations:
                if isinstance(v, dict):
                    aggregations_list.append(v)
                else:
                    aggregations_list.append(v.to_dict())
            _dict['aggregations'] = aggregations_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ComponentSettingsResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ComponentSettingsResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ComponentSettingsResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class CreateDocumentClassifier:
    """
    An object that manages the settings and data that is required to train a document
    classification model.

    :param str name: A human-readable name of the document classifier.
    :param str description: (optional) A description of the document classifier.
    :param str language: The language of the training data that is associated with
          the document classifier. Language is specified by using the ISO 639-1 language
          code, such as `en` for English or `ja` for Japanese.
    :param str answer_field: The name of the field from the training and test data
          that contains the classification labels.
    :param List[DocumentClassifierEnrichment] enrichments: (optional) An array of
          enrichments to apply to the data that is used to train and test the document
          classifier. The output from the enrichments is used as features by the
          classifier to classify the document content both during training and at run
          time.
    :param ClassifierFederatedModel federated_classification: (optional) An object
          with details for creating federated document classifier models.
    """

    def __init__(
        self,
        name: str,
        language: str,
        answer_field: str,
        *,
        description: Optional[str] = None,
        enrichments: Optional[List['DocumentClassifierEnrichment']] = None,
        federated_classification: Optional['ClassifierFederatedModel'] = None,
    ) -> None:
        """
        Initialize a CreateDocumentClassifier object.

        :param str name: A human-readable name of the document classifier.
        :param str language: The language of the training data that is associated
               with the document classifier. Language is specified by using the ISO 639-1
               language code, such as `en` for English or `ja` for Japanese.
        :param str answer_field: The name of the field from the training and test
               data that contains the classification labels.
        :param str description: (optional) A description of the document
               classifier.
        :param List[DocumentClassifierEnrichment] enrichments: (optional) An array
               of enrichments to apply to the data that is used to train and test the
               document classifier. The output from the enrichments is used as features by
               the classifier to classify the document content both during training and at
               run time.
        :param ClassifierFederatedModel federated_classification: (optional) An
               object with details for creating federated document classifier models.
        """
        self.name = name
        self.description = description
        self.language = language
        self.answer_field = answer_field
        self.enrichments = enrichments
        self.federated_classification = federated_classification

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'CreateDocumentClassifier':
        """Initialize a CreateDocumentClassifier object from a json dictionary."""
        args = {}
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        else:
            raise ValueError(
                'Required property \'name\' not present in CreateDocumentClassifier JSON'
            )
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        if (language := _dict.get('language')) is not None:
            args['language'] = language
        else:
            raise ValueError(
                'Required property \'language\' not present in CreateDocumentClassifier JSON'
            )
        if (answer_field := _dict.get('answer_field')) is not None:
            args['answer_field'] = answer_field
        else:
            raise ValueError(
                'Required property \'answer_field\' not present in CreateDocumentClassifier JSON'
            )
        if (enrichments := _dict.get('enrichments')) is not None:
            args['enrichments'] = [
                DocumentClassifierEnrichment.from_dict(v) for v in enrichments
            ]
        if (federated_classification :=
                _dict.get('federated_classification')) is not None:
            args[
                'federated_classification'] = ClassifierFederatedModel.from_dict(
                    federated_classification)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a CreateDocumentClassifier object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        if hasattr(self, 'language') and self.language is not None:
            _dict['language'] = self.language
        if hasattr(self, 'answer_field') and self.answer_field is not None:
            _dict['answer_field'] = self.answer_field
        if hasattr(self, 'enrichments') and self.enrichments is not None:
            enrichments_list = []
            for v in self.enrichments:
                if isinstance(v, dict):
                    enrichments_list.append(v)
                else:
                    enrichments_list.append(v.to_dict())
            _dict['enrichments'] = enrichments_list
        if hasattr(self, 'federated_classification'
                  ) and self.federated_classification is not None:
            if isinstance(self.federated_classification, dict):
                _dict[
                    'federated_classification'] = self.federated_classification
            else:
                _dict[
                    'federated_classification'] = self.federated_classification.to_dict(
                    )
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this CreateDocumentClassifier object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'CreateDocumentClassifier') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'CreateDocumentClassifier') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class CreateEnrichment:
    """
    Information about a specific enrichment.

    :param str name: (optional) The human readable name for this enrichment.
    :param str description: (optional) The description of this enrichment.
    :param str type: (optional) The type of this enrichment. The following types are
          supported:
          * `classifier`: Creates a document classifier enrichment from a document
          classifier model that you create by using the [Document classifier
          API](/apidocs/discovery-data#createdocumentclassifier). **Note**: A text
          classifier enrichment can be created only from the product user interface.
          * `dictionary`: Creates a custom dictionary enrichment that you define in a CSV
          file.
          * `regular_expression`: Creates a custom regular expression enrichment from
          regex syntax that you specify in the request.
          * `rule_based`: Creates an enrichment from an advanced rules model that is
          created and exported as a ZIP file from Watson Knowledge Studio.
          * `uima_annotator`: Creates an enrichment from a custom UIMA text analysis model
          that is defined in a PEAR file created in one of the following ways:
              * Watson Explorer Content Analytics Studio. **Note**: Supported in IBM Cloud
          Pak for Data instances only.
              * Rule-based model that is created in Watson Knowledge Studio.
          * `watson_knowledge_studio_model`: Creates an enrichment from a Watson Knowledge
          Studio machine learning model that is defined in a ZIP file.
          * `webhook`: Connects to an external enrichment application by using a webhook.
          * `sentence_classifier`: Use sentence classifier to classify sentences in your
          documents. This feature is available in IBM Cloud-managed instances only. The
          sentence classifier feature is beta functionality. Beta features are not
          supported by the SDKs.
    :param EnrichmentOptions options: (optional) An object that contains options for
          the current enrichment. Starting with version `2020-08-30`, the enrichment
          options are not included in responses from the List Enrichments method.
    """

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        description: Optional[str] = None,
        type: Optional[str] = None,
        options: Optional['EnrichmentOptions'] = None,
    ) -> None:
        """
        Initialize a CreateEnrichment object.

        :param str name: (optional) The human readable name for this enrichment.
        :param str description: (optional) The description of this enrichment.
        :param str type: (optional) The type of this enrichment. The following
               types are supported:
               * `classifier`: Creates a document classifier enrichment from a document
               classifier model that you create by using the [Document classifier
               API](/apidocs/discovery-data#createdocumentclassifier). **Note**: A text
               classifier enrichment can be created only from the product user interface.
               * `dictionary`: Creates a custom dictionary enrichment that you define in a
               CSV file.
               * `regular_expression`: Creates a custom regular expression enrichment from
               regex syntax that you specify in the request.
               * `rule_based`: Creates an enrichment from an advanced rules model that is
               created and exported as a ZIP file from Watson Knowledge Studio.
               * `uima_annotator`: Creates an enrichment from a custom UIMA text analysis
               model that is defined in a PEAR file created in one of the following ways:
                   * Watson Explorer Content Analytics Studio. **Note**: Supported in IBM
               Cloud Pak for Data instances only.
                   * Rule-based model that is created in Watson Knowledge Studio.
               * `watson_knowledge_studio_model`: Creates an enrichment from a Watson
               Knowledge Studio machine learning model that is defined in a ZIP file.
               * `webhook`: Connects to an external enrichment application by using a
               webhook.
               * `sentence_classifier`: Use sentence classifier to classify sentences in
               your documents. This feature is available in IBM Cloud-managed instances
               only. The sentence classifier feature is beta functionality. Beta features
               are not supported by the SDKs.
        :param EnrichmentOptions options: (optional) An object that contains
               options for the current enrichment. Starting with version `2020-08-30`, the
               enrichment options are not included in responses from the List Enrichments
               method.
        """
        self.name = name
        self.description = description
        self.type = type
        self.options = options

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'CreateEnrichment':
        """Initialize a CreateEnrichment object from a json dictionary."""
        args = {}
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (options := _dict.get('options')) is not None:
            args['options'] = EnrichmentOptions.from_dict(options)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a CreateEnrichment object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'options') and self.options is not None:
            if isinstance(self.options, dict):
                _dict['options'] = self.options
            else:
                _dict['options'] = self.options.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this CreateEnrichment object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'CreateEnrichment') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'CreateEnrichment') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class TypeEnum(str, Enum):
        """
        The type of this enrichment. The following types are supported:
        * `classifier`: Creates a document classifier enrichment from a document
        classifier model that you create by using the [Document classifier
        API](/apidocs/discovery-data#createdocumentclassifier). **Note**: A text
        classifier enrichment can be created only from the product user interface.
        * `dictionary`: Creates a custom dictionary enrichment that you define in a CSV
        file.
        * `regular_expression`: Creates a custom regular expression enrichment from regex
        syntax that you specify in the request.
        * `rule_based`: Creates an enrichment from an advanced rules model that is created
        and exported as a ZIP file from Watson Knowledge Studio.
        * `uima_annotator`: Creates an enrichment from a custom UIMA text analysis model
        that is defined in a PEAR file created in one of the following ways:
            * Watson Explorer Content Analytics Studio. **Note**: Supported in IBM Cloud
        Pak for Data instances only.
            * Rule-based model that is created in Watson Knowledge Studio.
        * `watson_knowledge_studio_model`: Creates an enrichment from a Watson Knowledge
        Studio machine learning model that is defined in a ZIP file.
        * `webhook`: Connects to an external enrichment application by using a webhook.
        * `sentence_classifier`: Use sentence classifier to classify sentences in your
        documents. This feature is available in IBM Cloud-managed instances only. The
        sentence classifier feature is beta functionality. Beta features are not supported
        by the SDKs.
        """

        CLASSIFIER = 'classifier'
        DICTIONARY = 'dictionary'
        REGULAR_EXPRESSION = 'regular_expression'
        UIMA_ANNOTATOR = 'uima_annotator'
        RULE_BASED = 'rule_based'
        WATSON_KNOWLEDGE_STUDIO_MODEL = 'watson_knowledge_studio_model'
        WEBHOOK = 'webhook'
        SENTENCE_CLASSIFIER = 'sentence_classifier'


class DefaultQueryParams:
    """
    Default query parameters for this project.

    :param List[str] collection_ids: (optional) An array of collection identifiers
          to query. If empty or omitted all collections in the project are queried.
    :param DefaultQueryParamsPassages passages: (optional) Default settings
          configuration for passage search options.
    :param DefaultQueryParamsTableResults table_results: (optional) Default project
          query settings for table results.
    :param str aggregation: (optional) A string representing the default aggregation
          query for the project.
    :param DefaultQueryParamsSuggestedRefinements suggested_refinements: (optional)
          Object that contains suggested refinement settings.
          **Note**: The `suggested_refinements` parameter that identified dynamic facets
          from the data is deprecated.
    :param bool spelling_suggestions: (optional) When `true`, a spelling suggestions
          for the query are returned by default.
    :param bool highlight: (optional) When `true`, highlights for the query are
          returned by default.
    :param int count: (optional) The number of document results returned by default.
    :param str sort: (optional) A comma separated list of document fields to sort
          results by default.
    :param List[str] return_: (optional) An array of field names to return in
          document results if present by default.
    """

    def __init__(
        self,
        *,
        collection_ids: Optional[List[str]] = None,
        passages: Optional['DefaultQueryParamsPassages'] = None,
        table_results: Optional['DefaultQueryParamsTableResults'] = None,
        aggregation: Optional[str] = None,
        suggested_refinements: Optional[
            'DefaultQueryParamsSuggestedRefinements'] = None,
        spelling_suggestions: Optional[bool] = None,
        highlight: Optional[bool] = None,
        count: Optional[int] = None,
        sort: Optional[str] = None,
        return_: Optional[List[str]] = None,
    ) -> None:
        """
        Initialize a DefaultQueryParams object.

        :param List[str] collection_ids: (optional) An array of collection
               identifiers to query. If empty or omitted all collections in the project
               are queried.
        :param DefaultQueryParamsPassages passages: (optional) Default settings
               configuration for passage search options.
        :param DefaultQueryParamsTableResults table_results: (optional) Default
               project query settings for table results.
        :param str aggregation: (optional) A string representing the default
               aggregation query for the project.
        :param DefaultQueryParamsSuggestedRefinements suggested_refinements:
               (optional) Object that contains suggested refinement settings.
               **Note**: The `suggested_refinements` parameter that identified dynamic
               facets from the data is deprecated.
        :param bool spelling_suggestions: (optional) When `true`, a spelling
               suggestions for the query are returned by default.
        :param bool highlight: (optional) When `true`, highlights for the query are
               returned by default.
        :param int count: (optional) The number of document results returned by
               default.
        :param str sort: (optional) A comma separated list of document fields to
               sort results by default.
        :param List[str] return_: (optional) An array of field names to return in
               document results if present by default.
        """
        self.collection_ids = collection_ids
        self.passages = passages
        self.table_results = table_results
        self.aggregation = aggregation
        self.suggested_refinements = suggested_refinements
        self.spelling_suggestions = spelling_suggestions
        self.highlight = highlight
        self.count = count
        self.sort = sort
        self.return_ = return_

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DefaultQueryParams':
        """Initialize a DefaultQueryParams object from a json dictionary."""
        args = {}
        if (collection_ids := _dict.get('collection_ids')) is not None:
            args['collection_ids'] = collection_ids
        if (passages := _dict.get('passages')) is not None:
            args['passages'] = DefaultQueryParamsPassages.from_dict(passages)
        if (table_results := _dict.get('table_results')) is not None:
            args['table_results'] = DefaultQueryParamsTableResults.from_dict(
                table_results)
        if (aggregation := _dict.get('aggregation')) is not None:
            args['aggregation'] = aggregation
        if (suggested_refinements :=
                _dict.get('suggested_refinements')) is not None:
            args[
                'suggested_refinements'] = DefaultQueryParamsSuggestedRefinements.from_dict(
                    suggested_refinements)
        if (spelling_suggestions :=
                _dict.get('spelling_suggestions')) is not None:
            args['spelling_suggestions'] = spelling_suggestions
        if (highlight := _dict.get('highlight')) is not None:
            args['highlight'] = highlight
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        if (sort := _dict.get('sort')) is not None:
            args['sort'] = sort
        if (return_ := _dict.get('return')) is not None:
            args['return_'] = return_
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DefaultQueryParams object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'collection_ids') and self.collection_ids is not None:
            _dict['collection_ids'] = self.collection_ids
        if hasattr(self, 'passages') and self.passages is not None:
            if isinstance(self.passages, dict):
                _dict['passages'] = self.passages
            else:
                _dict['passages'] = self.passages.to_dict()
        if hasattr(self, 'table_results') and self.table_results is not None:
            if isinstance(self.table_results, dict):
                _dict['table_results'] = self.table_results
            else:
                _dict['table_results'] = self.table_results.to_dict()
        if hasattr(self, 'aggregation') and self.aggregation is not None:
            _dict['aggregation'] = self.aggregation
        if hasattr(self, 'suggested_refinements'
                  ) and self.suggested_refinements is not None:
            if isinstance(self.suggested_refinements, dict):
                _dict['suggested_refinements'] = self.suggested_refinements
            else:
                _dict[
                    'suggested_refinements'] = self.suggested_refinements.to_dict(
                    )
        if hasattr(self, 'spelling_suggestions'
                  ) and self.spelling_suggestions is not None:
            _dict['spelling_suggestions'] = self.spelling_suggestions
        if hasattr(self, 'highlight') and self.highlight is not None:
            _dict['highlight'] = self.highlight
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        if hasattr(self, 'sort') and self.sort is not None:
            _dict['sort'] = self.sort
        if hasattr(self, 'return_') and self.return_ is not None:
            _dict['return'] = self.return_
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DefaultQueryParams object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DefaultQueryParams') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DefaultQueryParams') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DefaultQueryParamsPassages:
    """
    Default settings configuration for passage search options.

    :param bool enabled: (optional) When `true`, a passage search is performed by
          default.
    :param int count: (optional) The number of passages to return.
    :param List[str] fields: (optional) An array of field names to perform the
          passage search on.
    :param int characters: (optional) The approximate number of characters that each
          returned passage will contain.
    :param bool per_document: (optional) When `true` the number of passages that can
          be returned from a single document is restricted to the *max_per_document*
          value.
    :param int max_per_document: (optional) The default maximum number of passages
          that can be taken from a single document as the result of a passage query.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        count: Optional[int] = None,
        fields: Optional[List[str]] = None,
        characters: Optional[int] = None,
        per_document: Optional[bool] = None,
        max_per_document: Optional[int] = None,
    ) -> None:
        """
        Initialize a DefaultQueryParamsPassages object.

        :param bool enabled: (optional) When `true`, a passage search is performed
               by default.
        :param int count: (optional) The number of passages to return.
        :param List[str] fields: (optional) An array of field names to perform the
               passage search on.
        :param int characters: (optional) The approximate number of characters that
               each returned passage will contain.
        :param bool per_document: (optional) When `true` the number of passages
               that can be returned from a single document is restricted to the
               *max_per_document* value.
        :param int max_per_document: (optional) The default maximum number of
               passages that can be taken from a single document as the result of a
               passage query.
        """
        self.enabled = enabled
        self.count = count
        self.fields = fields
        self.characters = characters
        self.per_document = per_document
        self.max_per_document = max_per_document

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DefaultQueryParamsPassages':
        """Initialize a DefaultQueryParamsPassages object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        if (fields := _dict.get('fields')) is not None:
            args['fields'] = fields
        if (characters := _dict.get('characters')) is not None:
            args['characters'] = characters
        if (per_document := _dict.get('per_document')) is not None:
            args['per_document'] = per_document
        if (max_per_document := _dict.get('max_per_document')) is not None:
            args['max_per_document'] = max_per_document
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DefaultQueryParamsPassages object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        if hasattr(self, 'fields') and self.fields is not None:
            _dict['fields'] = self.fields
        if hasattr(self, 'characters') and self.characters is not None:
            _dict['characters'] = self.characters
        if hasattr(self, 'per_document') and self.per_document is not None:
            _dict['per_document'] = self.per_document
        if hasattr(self,
                   'max_per_document') and self.max_per_document is not None:
            _dict['max_per_document'] = self.max_per_document
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DefaultQueryParamsPassages object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DefaultQueryParamsPassages') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DefaultQueryParamsPassages') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DefaultQueryParamsSuggestedRefinements:
    """
    Object that contains suggested refinement settings.
    **Note**: The `suggested_refinements` parameter that identified dynamic facets from
    the data is deprecated.

    :param bool enabled: (optional) When `true`, suggested refinements for the query
          are returned by default.
    :param int count: (optional) The number of suggested refinements to return by
          default.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        count: Optional[int] = None,
    ) -> None:
        """
        Initialize a DefaultQueryParamsSuggestedRefinements object.

        :param bool enabled: (optional) When `true`, suggested refinements for the
               query are returned by default.
        :param int count: (optional) The number of suggested refinements to return
               by default.
        """
        self.enabled = enabled
        self.count = count

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DefaultQueryParamsSuggestedRefinements':
        """Initialize a DefaultQueryParamsSuggestedRefinements object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DefaultQueryParamsSuggestedRefinements object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DefaultQueryParamsSuggestedRefinements object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DefaultQueryParamsSuggestedRefinements') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DefaultQueryParamsSuggestedRefinements') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DefaultQueryParamsTableResults:
    """
    Default project query settings for table results.

    :param bool enabled: (optional) When `true`, a table results for the query are
          returned by default.
    :param int count: (optional) The number of table results to return by default.
    :param int per_document: (optional) The number of table results to include in
          each result document.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        count: Optional[int] = None,
        per_document: Optional[int] = None,
    ) -> None:
        """
        Initialize a DefaultQueryParamsTableResults object.

        :param bool enabled: (optional) When `true`, a table results for the query
               are returned by default.
        :param int count: (optional) The number of table results to return by
               default.
        :param int per_document: (optional) The number of table results to include
               in each result document.
        """
        self.enabled = enabled
        self.count = count
        self.per_document = per_document

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DefaultQueryParamsTableResults':
        """Initialize a DefaultQueryParamsTableResults object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        if (per_document := _dict.get('per_document')) is not None:
            args['per_document'] = per_document
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DefaultQueryParamsTableResults object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        if hasattr(self, 'per_document') and self.per_document is not None:
            _dict['per_document'] = self.per_document
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DefaultQueryParamsTableResults object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DefaultQueryParamsTableResults') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DefaultQueryParamsTableResults') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DeleteDocumentResponse:
    """
    Information returned when a document is deleted.

    :param str document_id: (optional) The unique identifier of the document.
    :param str status: (optional) Status of the document. A deleted document has the
          status deleted.
    """

    def __init__(
        self,
        *,
        document_id: Optional[str] = None,
        status: Optional[str] = None,
    ) -> None:
        """
        Initialize a DeleteDocumentResponse object.

        :param str document_id: (optional) The unique identifier of the document.
        :param str status: (optional) Status of the document. A deleted document
               has the status deleted.
        """
        self.document_id = document_id
        self.status = status

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DeleteDocumentResponse':
        """Initialize a DeleteDocumentResponse object from a json dictionary."""
        args = {}
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        if (status := _dict.get('status')) is not None:
            args['status'] = status
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DeleteDocumentResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_id') and self.document_id is not None:
            _dict['document_id'] = self.document_id
        if hasattr(self, 'status') and self.status is not None:
            _dict['status'] = self.status
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DeleteDocumentResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DeleteDocumentResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DeleteDocumentResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class StatusEnum(str, Enum):
        """
        Status of the document. A deleted document has the status deleted.
        """

        DELETED = 'deleted'


class DocumentAccepted:
    """
    Information returned after an uploaded document is accepted.

    :param str document_id: (optional) The unique identifier of the ingested
          document.
    :param str status: (optional) Status of the document in the ingestion process. A
          status of `processing` is returned for documents that are ingested with a
          *version* date before `2019-01-01`. The `pending` status is returned for all
          others.
    """

    def __init__(
        self,
        *,
        document_id: Optional[str] = None,
        status: Optional[str] = None,
    ) -> None:
        """
        Initialize a DocumentAccepted object.

        :param str document_id: (optional) The unique identifier of the ingested
               document.
        :param str status: (optional) Status of the document in the ingestion
               process. A status of `processing` is returned for documents that are
               ingested with a *version* date before `2019-01-01`. The `pending` status is
               returned for all others.
        """
        self.document_id = document_id
        self.status = status

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentAccepted':
        """Initialize a DocumentAccepted object from a json dictionary."""
        args = {}
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        if (status := _dict.get('status')) is not None:
            args['status'] = status
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentAccepted object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_id') and self.document_id is not None:
            _dict['document_id'] = self.document_id
        if hasattr(self, 'status') and self.status is not None:
            _dict['status'] = self.status
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentAccepted object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentAccepted') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentAccepted') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class StatusEnum(str, Enum):
        """
        Status of the document in the ingestion process. A status of `processing` is
        returned for documents that are ingested with a *version* date before
        `2019-01-01`. The `pending` status is returned for all others.
        """

        PROCESSING = 'processing'
        PENDING = 'pending'


class DocumentAttribute:
    """
    List of document attributes.

    :param str type: (optional) The type of attribute.
    :param str text: (optional) The text associated with the attribute.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    """

    def __init__(
        self,
        *,
        type: Optional[str] = None,
        text: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
    ) -> None:
        """
        Initialize a DocumentAttribute object.

        :param str type: (optional) The type of attribute.
        :param str text: (optional) The text associated with the attribute.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        """
        self.type = type
        self.text = text
        self.location = location

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentAttribute':
        """Initialize a DocumentAttribute object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentAttribute object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentAttribute object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentAttribute') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentAttribute') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DocumentClassifier:
    """
    Information about a document classifier.

    :param str classifier_id: (optional) The Universally Unique Identifier (UUID) of
          the document classifier.
    :param str name: A human-readable name of the document classifier.
    :param str description: (optional) A description of the document classifier.
    :param datetime created: (optional) The date that the document classifier was
          created.
    :param str language: (optional) The language of the training data that is
          associated with the document classifier. Language is specified by using the ISO
          639-1 language code, such as `en` for English or `ja` for Japanese.
    :param List[DocumentClassifierEnrichment] enrichments: (optional) An array of
          enrichments to apply to the data that is used to train and test the document
          classifier. The output from the enrichments is used as features by the
          classifier to classify the document content both during training and at run
          time.
    :param List[str] recognized_fields: (optional) An array of fields that are used
          to train the document classifier. The same set of fields must exist in the
          training data, the test data, and the documents where the resulting document
          classifier enrichment is applied at run time.
    :param str answer_field: (optional) The name of the field from the training and
          test data that contains the classification labels.
    :param str training_data_file: (optional) Name of the CSV file with training
          data that is used to train the document classifier.
    :param str test_data_file: (optional) Name of the CSV file with data that is
          used to test the document classifier. If no test data is provided, a subset of
          the training data is used for testing purposes.
    :param ClassifierFederatedModel federated_classification: (optional) An object
          with details for creating federated document classifier models.
    """

    def __init__(
        self,
        name: str,
        *,
        classifier_id: Optional[str] = None,
        description: Optional[str] = None,
        created: Optional[datetime] = None,
        language: Optional[str] = None,
        enrichments: Optional[List['DocumentClassifierEnrichment']] = None,
        recognized_fields: Optional[List[str]] = None,
        answer_field: Optional[str] = None,
        training_data_file: Optional[str] = None,
        test_data_file: Optional[str] = None,
        federated_classification: Optional['ClassifierFederatedModel'] = None,
    ) -> None:
        """
        Initialize a DocumentClassifier object.

        :param str name: A human-readable name of the document classifier.
        :param str description: (optional) A description of the document
               classifier.
        :param str language: (optional) The language of the training data that is
               associated with the document classifier. Language is specified by using the
               ISO 639-1 language code, such as `en` for English or `ja` for Japanese.
        :param List[DocumentClassifierEnrichment] enrichments: (optional) An array
               of enrichments to apply to the data that is used to train and test the
               document classifier. The output from the enrichments is used as features by
               the classifier to classify the document content both during training and at
               run time.
        :param List[str] recognized_fields: (optional) An array of fields that are
               used to train the document classifier. The same set of fields must exist in
               the training data, the test data, and the documents where the resulting
               document classifier enrichment is applied at run time.
        :param str answer_field: (optional) The name of the field from the training
               and test data that contains the classification labels.
        :param str training_data_file: (optional) Name of the CSV file with
               training data that is used to train the document classifier.
        :param str test_data_file: (optional) Name of the CSV file with data that
               is used to test the document classifier. If no test data is provided, a
               subset of the training data is used for testing purposes.
        :param ClassifierFederatedModel federated_classification: (optional) An
               object with details for creating federated document classifier models.
        """
        self.classifier_id = classifier_id
        self.name = name
        self.description = description
        self.created = created
        self.language = language
        self.enrichments = enrichments
        self.recognized_fields = recognized_fields
        self.answer_field = answer_field
        self.training_data_file = training_data_file
        self.test_data_file = test_data_file
        self.federated_classification = federated_classification

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentClassifier':
        """Initialize a DocumentClassifier object from a json dictionary."""
        args = {}
        if (classifier_id := _dict.get('classifier_id')) is not None:
            args['classifier_id'] = classifier_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        else:
            raise ValueError(
                'Required property \'name\' not present in DocumentClassifier JSON'
            )
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (language := _dict.get('language')) is not None:
            args['language'] = language
        if (enrichments := _dict.get('enrichments')) is not None:
            args['enrichments'] = [
                DocumentClassifierEnrichment.from_dict(v) for v in enrichments
            ]
        if (recognized_fields := _dict.get('recognized_fields')) is not None:
            args['recognized_fields'] = recognized_fields
        if (answer_field := _dict.get('answer_field')) is not None:
            args['answer_field'] = answer_field
        if (training_data_file := _dict.get('training_data_file')) is not None:
            args['training_data_file'] = training_data_file
        if (test_data_file := _dict.get('test_data_file')) is not None:
            args['test_data_file'] = test_data_file
        if (federated_classification :=
                _dict.get('federated_classification')) is not None:
            args[
                'federated_classification'] = ClassifierFederatedModel.from_dict(
                    federated_classification)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentClassifier object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'classifier_id') and getattr(
                self, 'classifier_id') is not None:
            _dict['classifier_id'] = getattr(self, 'classifier_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'language') and self.language is not None:
            _dict['language'] = self.language
        if hasattr(self, 'enrichments') and self.enrichments is not None:
            enrichments_list = []
            for v in self.enrichments:
                if isinstance(v, dict):
                    enrichments_list.append(v)
                else:
                    enrichments_list.append(v.to_dict())
            _dict['enrichments'] = enrichments_list
        if hasattr(self,
                   'recognized_fields') and self.recognized_fields is not None:
            _dict['recognized_fields'] = self.recognized_fields
        if hasattr(self, 'answer_field') and self.answer_field is not None:
            _dict['answer_field'] = self.answer_field
        if hasattr(
                self,
                'training_data_file') and self.training_data_file is not None:
            _dict['training_data_file'] = self.training_data_file
        if hasattr(self, 'test_data_file') and self.test_data_file is not None:
            _dict['test_data_file'] = self.test_data_file
        if hasattr(self, 'federated_classification'
                  ) and self.federated_classification is not None:
            if isinstance(self.federated_classification, dict):
                _dict[
                    'federated_classification'] = self.federated_classification
            else:
                _dict[
                    'federated_classification'] = self.federated_classification.to_dict(
                    )
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentClassifier object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentClassifier') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentClassifier') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DocumentClassifierEnrichment:
    """
    An object that describes enrichments that are applied to the training and test data
    that is used by the document classifier.

    :param str enrichment_id: The Universally Unique Identifier (UUID) of the
          enrichment.
    :param List[str] fields: An array of field names where the enrichment is
          applied.
    """

    def __init__(
        self,
        enrichment_id: str,
        fields: List[str],
    ) -> None:
        """
        Initialize a DocumentClassifierEnrichment object.

        :param str enrichment_id: The Universally Unique Identifier (UUID) of the
               enrichment.
        :param List[str] fields: An array of field names where the enrichment is
               applied.
        """
        self.enrichment_id = enrichment_id
        self.fields = fields

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentClassifierEnrichment':
        """Initialize a DocumentClassifierEnrichment object from a json dictionary."""
        args = {}
        if (enrichment_id := _dict.get('enrichment_id')) is not None:
            args['enrichment_id'] = enrichment_id
        else:
            raise ValueError(
                'Required property \'enrichment_id\' not present in DocumentClassifierEnrichment JSON'
            )
        if (fields := _dict.get('fields')) is not None:
            args['fields'] = fields
        else:
            raise ValueError(
                'Required property \'fields\' not present in DocumentClassifierEnrichment JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentClassifierEnrichment object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enrichment_id') and self.enrichment_id is not None:
            _dict['enrichment_id'] = self.enrichment_id
        if hasattr(self, 'fields') and self.fields is not None:
            _dict['fields'] = self.fields
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentClassifierEnrichment object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentClassifierEnrichment') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentClassifierEnrichment') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DocumentClassifierModel:
    """
    Information about a document classifier model.

    :param str model_id: (optional) The Universally Unique Identifier (UUID) of the
          document classifier model.
    :param str name: A human-readable name of the document classifier model.
    :param str description: (optional) A description of the document classifier
          model.
    :param datetime created: (optional) The date that the document classifier model
          was created.
    :param datetime updated: (optional) The date that the document classifier model
          was last updated.
    :param str training_data_file: (optional) Name of the CSV file that contains the
          training data that is used to train the document classifier model.
    :param str test_data_file: (optional) Name of the CSV file that contains data
          that is used to test the document classifier model. If no test data is provided,
          a subset of the training data is used for testing purposes.
    :param str status: (optional) The status of the training run.
    :param ClassifierModelEvaluation evaluation: (optional) An object that contains
          information about a trained document classifier model.
    :param str enrichment_id: (optional) The Universally Unique Identifier (UUID) of
          the enrichment that is generated by this document classifier model.
    :param datetime deployed_at: (optional) The date that the document classifier
          model was deployed.
    """

    def __init__(
        self,
        name: str,
        *,
        model_id: Optional[str] = None,
        description: Optional[str] = None,
        created: Optional[datetime] = None,
        updated: Optional[datetime] = None,
        training_data_file: Optional[str] = None,
        test_data_file: Optional[str] = None,
        status: Optional[str] = None,
        evaluation: Optional['ClassifierModelEvaluation'] = None,
        enrichment_id: Optional[str] = None,
        deployed_at: Optional[datetime] = None,
    ) -> None:
        """
        Initialize a DocumentClassifierModel object.

        :param str name: A human-readable name of the document classifier model.
        :param str description: (optional) A description of the document classifier
               model.
        :param str training_data_file: (optional) Name of the CSV file that
               contains the training data that is used to train the document classifier
               model.
        :param str test_data_file: (optional) Name of the CSV file that contains
               data that is used to test the document classifier model. If no test data is
               provided, a subset of the training data is used for testing purposes.
        :param str status: (optional) The status of the training run.
        :param ClassifierModelEvaluation evaluation: (optional) An object that
               contains information about a trained document classifier model.
        :param str enrichment_id: (optional) The Universally Unique Identifier
               (UUID) of the enrichment that is generated by this document classifier
               model.
        """
        self.model_id = model_id
        self.name = name
        self.description = description
        self.created = created
        self.updated = updated
        self.training_data_file = training_data_file
        self.test_data_file = test_data_file
        self.status = status
        self.evaluation = evaluation
        self.enrichment_id = enrichment_id
        self.deployed_at = deployed_at

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentClassifierModel':
        """Initialize a DocumentClassifierModel object from a json dictionary."""
        args = {}
        if (model_id := _dict.get('model_id')) is not None:
            args['model_id'] = model_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        else:
            raise ValueError(
                'Required property \'name\' not present in DocumentClassifierModel JSON'
            )
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (updated := _dict.get('updated')) is not None:
            args['updated'] = string_to_datetime(updated)
        if (training_data_file := _dict.get('training_data_file')) is not None:
            args['training_data_file'] = training_data_file
        if (test_data_file := _dict.get('test_data_file')) is not None:
            args['test_data_file'] = test_data_file
        if (status := _dict.get('status')) is not None:
            args['status'] = status
        if (evaluation := _dict.get('evaluation')) is not None:
            args['evaluation'] = ClassifierModelEvaluation.from_dict(evaluation)
        if (enrichment_id := _dict.get('enrichment_id')) is not None:
            args['enrichment_id'] = enrichment_id
        if (deployed_at := _dict.get('deployed_at')) is not None:
            args['deployed_at'] = string_to_datetime(deployed_at)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentClassifierModel object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'model_id') and getattr(self, 'model_id') is not None:
            _dict['model_id'] = getattr(self, 'model_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'updated') and getattr(self, 'updated') is not None:
            _dict['updated'] = datetime_to_string(getattr(self, 'updated'))
        if hasattr(
                self,
                'training_data_file') and self.training_data_file is not None:
            _dict['training_data_file'] = self.training_data_file
        if hasattr(self, 'test_data_file') and self.test_data_file is not None:
            _dict['test_data_file'] = self.test_data_file
        if hasattr(self, 'status') and self.status is not None:
            _dict['status'] = self.status
        if hasattr(self, 'evaluation') and self.evaluation is not None:
            if isinstance(self.evaluation, dict):
                _dict['evaluation'] = self.evaluation
            else:
                _dict['evaluation'] = self.evaluation.to_dict()
        if hasattr(self, 'enrichment_id') and self.enrichment_id is not None:
            _dict['enrichment_id'] = self.enrichment_id
        if hasattr(self, 'deployed_at') and getattr(self,
                                                    'deployed_at') is not None:
            _dict['deployed_at'] = datetime_to_string(
                getattr(self, 'deployed_at'))
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentClassifierModel object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentClassifierModel') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentClassifierModel') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class StatusEnum(str, Enum):
        """
        The status of the training run.
        """

        TRAINING = 'training'
        AVAILABLE = 'available'
        FAILED = 'failed'


class DocumentClassifierModels:
    """
    An object that contains a list of document classifier model definitions.

    :param List[DocumentClassifierModel] models: (optional) An array of document
          classifier model definitions.
    """

    def __init__(
        self,
        *,
        models: Optional[List['DocumentClassifierModel']] = None,
    ) -> None:
        """
        Initialize a DocumentClassifierModels object.

        :param List[DocumentClassifierModel] models: (optional) An array of
               document classifier model definitions.
        """
        self.models = models

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentClassifierModels':
        """Initialize a DocumentClassifierModels object from a json dictionary."""
        args = {}
        if (models := _dict.get('models')) is not None:
            args['models'] = [
                DocumentClassifierModel.from_dict(v) for v in models
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentClassifierModels object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'models') and self.models is not None:
            models_list = []
            for v in self.models:
                if isinstance(v, dict):
                    models_list.append(v)
                else:
                    models_list.append(v.to_dict())
            _dict['models'] = models_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentClassifierModels object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentClassifierModels') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentClassifierModels') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DocumentClassifiers:
    """
    An object that contains a list of document classifier definitions.

    :param List[DocumentClassifier] classifiers: (optional) An array of document
          classifier definitions.
    """

    def __init__(
        self,
        *,
        classifiers: Optional[List['DocumentClassifier']] = None,
    ) -> None:
        """
        Initialize a DocumentClassifiers object.

        :param List[DocumentClassifier] classifiers: (optional) An array of
               document classifier definitions.
        """
        self.classifiers = classifiers

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentClassifiers':
        """Initialize a DocumentClassifiers object from a json dictionary."""
        args = {}
        if (classifiers := _dict.get('classifiers')) is not None:
            args['classifiers'] = [
                DocumentClassifier.from_dict(v) for v in classifiers
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentClassifiers object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'classifiers') and self.classifiers is not None:
            classifiers_list = []
            for v in self.classifiers:
                if isinstance(v, dict):
                    classifiers_list.append(v)
                else:
                    classifiers_list.append(v.to_dict())
            _dict['classifiers'] = classifiers_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentClassifiers object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentClassifiers') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentClassifiers') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class DocumentDetails:
    """
    Information about a document.

    :param str document_id: (optional) The unique identifier of the document.
    :param datetime created: (optional) Date and time that the document is added to
          the collection. For a child document, the date and time when the process that
          generates the child document runs. The date-time format is
          `yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`.
    :param datetime updated: (optional) Date and time that the document is finished
          being processed and is indexed. This date changes whenever the document is
          reprocessed, including for enrichment changes. The date-time format is
          `yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`.
    :param str status: (optional) The status of the ingestion of the document. The
          possible values are:
          * `available`: Ingestion is finished and the document is indexed.
          * `failed`: Ingestion is finished, but the document is not indexed because of an
          error.
          * `pending`: The document is uploaded, but the ingestion process is not started.
          * `processing`: Ingestion is in progress.
    :param List[Notice] notices: (optional) Array of JSON objects for notices,
          meaning warning or error messages, that are produced by the document ingestion
          process. The array does not include notices that are produced for child
          documents that are generated when a document is processed.
    :param DocumentDetailsChildren children: (optional) Information about the child
          documents that are generated from a single document during ingestion or other
          processing.
    :param str filename: (optional) Name of the original source file (if available).
    :param str file_type: (optional) The type of the original source file, such as
          `csv`, `excel`, `html`, `json`, `pdf`, `text`, `word`, and so on.
    :param str sha256: (optional) The SHA-256 hash of the original source file. The
          hash is formatted as a hexadecimal string.
    """

    def __init__(
        self,
        *,
        document_id: Optional[str] = None,
        created: Optional[datetime] = None,
        updated: Optional[datetime] = None,
        status: Optional[str] = None,
        notices: Optional[List['Notice']] = None,
        children: Optional['DocumentDetailsChildren'] = None,
        filename: Optional[str] = None,
        file_type: Optional[str] = None,
        sha256: Optional[str] = None,
    ) -> None:
        """
        Initialize a DocumentDetails object.

        :param str status: (optional) The status of the ingestion of the document.
               The possible values are:
               * `available`: Ingestion is finished and the document is indexed.
               * `failed`: Ingestion is finished, but the document is not indexed because
               of an error.
               * `pending`: The document is uploaded, but the ingestion process is not
               started.
               * `processing`: Ingestion is in progress.
        :param List[Notice] notices: (optional) Array of JSON objects for notices,
               meaning warning or error messages, that are produced by the document
               ingestion process. The array does not include notices that are produced for
               child documents that are generated when a document is processed.
        :param DocumentDetailsChildren children: (optional) Information about the
               child documents that are generated from a single document during ingestion
               or other processing.
        :param str filename: (optional) Name of the original source file (if
               available).
        :param str file_type: (optional) The type of the original source file, such
               as `csv`, `excel`, `html`, `json`, `pdf`, `text`, `word`, and so on.
        :param str sha256: (optional) The SHA-256 hash of the original source file.
               The hash is formatted as a hexadecimal string.
        """
        self.document_id = document_id
        self.created = created
        self.updated = updated
        self.status = status
        self.notices = notices
        self.children = children
        self.filename = filename
        self.file_type = file_type
        self.sha256 = sha256

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentDetails':
        """Initialize a DocumentDetails object from a json dictionary."""
        args = {}
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (updated := _dict.get('updated')) is not None:
            args['updated'] = string_to_datetime(updated)
        if (status := _dict.get('status')) is not None:
            args['status'] = status
        if (notices := _dict.get('notices')) is not None:
            args['notices'] = [Notice.from_dict(v) for v in notices]
        if (children := _dict.get('children')) is not None:
            args['children'] = DocumentDetailsChildren.from_dict(children)
        if (filename := _dict.get('filename')) is not None:
            args['filename'] = filename
        if (file_type := _dict.get('file_type')) is not None:
            args['file_type'] = file_type
        if (sha256 := _dict.get('sha256')) is not None:
            args['sha256'] = sha256
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentDetails object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_id') and getattr(self,
                                                    'document_id') is not None:
            _dict['document_id'] = getattr(self, 'document_id')
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'updated') and getattr(self, 'updated') is not None:
            _dict['updated'] = datetime_to_string(getattr(self, 'updated'))
        if hasattr(self, 'status') and self.status is not None:
            _dict['status'] = self.status
        if hasattr(self, 'notices') and self.notices is not None:
            notices_list = []
            for v in self.notices:
                if isinstance(v, dict):
                    notices_list.append(v)
                else:
                    notices_list.append(v.to_dict())
            _dict['notices'] = notices_list
        if hasattr(self, 'children') and self.children is not None:
            if isinstance(self.children, dict):
                _dict['children'] = self.children
            else:
                _dict['children'] = self.children.to_dict()
        if hasattr(self, 'filename') and self.filename is not None:
            _dict['filename'] = self.filename
        if hasattr(self, 'file_type') and self.file_type is not None:
            _dict['file_type'] = self.file_type
        if hasattr(self, 'sha256') and self.sha256 is not None:
            _dict['sha256'] = self.sha256
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentDetails object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentDetails') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentDetails') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class StatusEnum(str, Enum):
        """
        The status of the ingestion of the document. The possible values are:
        * `available`: Ingestion is finished and the document is indexed.
        * `failed`: Ingestion is finished, but the document is not indexed because of an
        error.
        * `pending`: The document is uploaded, but the ingestion process is not started.
        * `processing`: Ingestion is in progress.
        """

        AVAILABLE = 'available'
        FAILED = 'failed'
        PENDING = 'pending'
        PROCESSING = 'processing'


class DocumentDetailsChildren:
    """
    Information about the child documents that are generated from a single document during
    ingestion or other processing.

    :param bool have_notices: (optional) Indicates whether the child documents have
          any notices. The value is `false` if the document does not have child documents.
    :param int count: (optional) Number of child documents. The value is `0` when
          processing of the document doesn't generate any child documents.
    """

    def __init__(
        self,
        *,
        have_notices: Optional[bool] = None,
        count: Optional[int] = None,
    ) -> None:
        """
        Initialize a DocumentDetailsChildren object.

        :param bool have_notices: (optional) Indicates whether the child documents
               have any notices. The value is `false` if the document does not have child
               documents.
        :param int count: (optional) Number of child documents. The value is `0`
               when processing of the document doesn't generate any child documents.
        """
        self.have_notices = have_notices
        self.count = count

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'DocumentDetailsChildren':
        """Initialize a DocumentDetailsChildren object from a json dictionary."""
        args = {}
        if (have_notices := _dict.get('have_notices')) is not None:
            args['have_notices'] = have_notices
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a DocumentDetailsChildren object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'have_notices') and self.have_notices is not None:
            _dict['have_notices'] = self.have_notices
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this DocumentDetailsChildren object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'DocumentDetailsChildren') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'DocumentDetailsChildren') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Enrichment:
    """
    Information about a specific enrichment.

    :param str enrichment_id: (optional) The Universally Unique Identifier (UUID) of
          this enrichment.
    :param str name: (optional) The human readable name for this enrichment.
    :param str description: (optional) The description of this enrichment.
    :param str type: (optional) The type of this enrichment.
    :param EnrichmentOptions options: (optional) An object that contains options for
          the current enrichment. Starting with version `2020-08-30`, the enrichment
          options are not included in responses from the List Enrichments method.
    """

    def __init__(
        self,
        *,
        enrichment_id: Optional[str] = None,
        name: Optional[str] = None,
        description: Optional[str] = None,
        type: Optional[str] = None,
        options: Optional['EnrichmentOptions'] = None,
    ) -> None:
        """
        Initialize a Enrichment object.

        :param str name: (optional) The human readable name for this enrichment.
        :param str description: (optional) The description of this enrichment.
        :param str type: (optional) The type of this enrichment.
        :param EnrichmentOptions options: (optional) An object that contains
               options for the current enrichment. Starting with version `2020-08-30`, the
               enrichment options are not included in responses from the List Enrichments
               method.
        """
        self.enrichment_id = enrichment_id
        self.name = name
        self.description = description
        self.type = type
        self.options = options

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Enrichment':
        """Initialize a Enrichment object from a json dictionary."""
        args = {}
        if (enrichment_id := _dict.get('enrichment_id')) is not None:
            args['enrichment_id'] = enrichment_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (options := _dict.get('options')) is not None:
            args['options'] = EnrichmentOptions.from_dict(options)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Enrichment object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enrichment_id') and getattr(
                self, 'enrichment_id') is not None:
            _dict['enrichment_id'] = getattr(self, 'enrichment_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'options') and self.options is not None:
            if isinstance(self.options, dict):
                _dict['options'] = self.options
            else:
                _dict['options'] = self.options.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Enrichment object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Enrichment') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Enrichment') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class TypeEnum(str, Enum):
        """
        The type of this enrichment.
        """

        PART_OF_SPEECH = 'part_of_speech'
        SENTIMENT = 'sentiment'
        NATURAL_LANGUAGE_UNDERSTANDING = 'natural_language_understanding'
        DICTIONARY = 'dictionary'
        REGULAR_EXPRESSION = 'regular_expression'
        UIMA_ANNOTATOR = 'uima_annotator'
        RULE_BASED = 'rule_based'
        WATSON_KNOWLEDGE_STUDIO_MODEL = 'watson_knowledge_studio_model'
        CLASSIFIER = 'classifier'
        WEBHOOK = 'webhook'
        SENTENCE_CLASSIFIER = 'sentence_classifier'


class EnrichmentOptions:
    """
    An object that contains options for the current enrichment. Starting with version
    `2020-08-30`, the enrichment options are not included in responses from the List
    Enrichments method.

    :param List[str] languages: (optional) An array of supported languages for this
          enrichment. When creating an enrichment, only specify a language that is used by
          the model or in the dictionary. Required when **type** is `dictionary`. Optional
          when **type** is `rule_based`. Not valid when creating any other type of
          enrichment.
    :param str entity_type: (optional) The name of the entity type. This value is
          used as the field name in the index. Required when **type** is `dictionary` or
          `regular_expression`. Not valid when creating any other type of enrichment.
    :param str regular_expression: (optional) The regular expression to apply for
          this enrichment. Required when **type** is `regular_expression`. Not valid when
          creating any other type of enrichment.
    :param str result_field: (optional) The name of the result document field that
          this enrichment creates. Required when **type** is `rule_based` or `classifier`.
          Not valid when creating any other type of enrichment.
    :param str classifier_id: (optional) The Universally Unique Identifier (UUID) of
          the document classifier. Required when **type** is `classifier`. Not valid when
          creating any other type of enrichment.
    :param str model_id: (optional) The Universally Unique Identifier (UUID) of the
          document classifier model. Required when **type** is `classifier`. Not valid
          when creating any other type of enrichment.
    :param float confidence_threshold: (optional) Specifies a threshold. Only
          classes with evaluation confidence scores that are higher than the specified
          threshold are included in the output. Optional when **type** is `classifier`.
          Not valid when creating any other type of enrichment.
    :param int top_k: (optional) Evaluates only the classes that fall in the top set
          of results when ranked by confidence. For example, if set to `5`, then the top
          five classes for each document are evaluated. If set to 0, the
          **confidence_threshold** is used to determine the predicted classes. Optional
          when **type** is `classifier`. Not valid when creating any other type of
          enrichment.
    :param str url: (optional) A URL that uses the SSL protocol (begins with https)
          for the webhook. Required when type is `webhook`. Not valid when creating any
          other type of enrichment.
    :param str version: (optional) The Discovery API version that allows to
          distinguish the schema. The version is specified in the `yyyy-mm-dd` format.
          Optional when `type` is `webhook`. Not valid when creating any other type of
          enrichment.
    :param str secret: (optional) A private key can be included in the request to
          authenticate with the external service. The maximum length is 1,024 characters.
          Optional when `type` is `webhook`. Not valid when creating any other type of
          enrichment.
    :param WebhookHeader headers_: (optional) An array of headers to pass with the
          HTTP request. Optional when `type` is `webhook`. Not valid when creating any
          other type of enrichment.
    :param str location_encoding: (optional) Discovery calculates offsets of the
          text's location with this encoding type in documents. Use the same location
          encoding type in both Discovery and external enrichment for a document.
           These encoding types are supported: `utf-8`, `utf-16`, and `utf-32`. Optional
          when `type` is `webhook`. Not valid when creating any other type of enrichment.
    """

    def __init__(
        self,
        *,
        languages: Optional[List[str]] = None,
        entity_type: Optional[str] = None,
        regular_expression: Optional[str] = None,
        result_field: Optional[str] = None,
        classifier_id: Optional[str] = None,
        model_id: Optional[str] = None,
        confidence_threshold: Optional[float] = None,
        top_k: Optional[int] = None,
        url: Optional[str] = None,
        version: Optional[str] = None,
        secret: Optional[str] = None,
        headers_: Optional['WebhookHeader'] = None,
        location_encoding: Optional[str] = None,
    ) -> None:
        """
        Initialize a EnrichmentOptions object.

        :param List[str] languages: (optional) An array of supported languages for
               this enrichment. When creating an enrichment, only specify a language that
               is used by the model or in the dictionary. Required when **type** is
               `dictionary`. Optional when **type** is `rule_based`. Not valid when
               creating any other type of enrichment.
        :param str entity_type: (optional) The name of the entity type. This value
               is used as the field name in the index. Required when **type** is
               `dictionary` or `regular_expression`. Not valid when creating any other
               type of enrichment.
        :param str regular_expression: (optional) The regular expression to apply
               for this enrichment. Required when **type** is `regular_expression`. Not
               valid when creating any other type of enrichment.
        :param str result_field: (optional) The name of the result document field
               that this enrichment creates. Required when **type** is `rule_based` or
               `classifier`. Not valid when creating any other type of enrichment.
        :param str classifier_id: (optional) The Universally Unique Identifier
               (UUID) of the document classifier. Required when **type** is `classifier`.
               Not valid when creating any other type of enrichment.
        :param str model_id: (optional) The Universally Unique Identifier (UUID) of
               the document classifier model. Required when **type** is `classifier`. Not
               valid when creating any other type of enrichment.
        :param float confidence_threshold: (optional) Specifies a threshold. Only
               classes with evaluation confidence scores that are higher than the
               specified threshold are included in the output. Optional when **type** is
               `classifier`. Not valid when creating any other type of enrichment.
        :param int top_k: (optional) Evaluates only the classes that fall in the
               top set of results when ranked by confidence. For example, if set to `5`,
               then the top five classes for each document are evaluated. If set to 0, the
               **confidence_threshold** is used to determine the predicted classes.
               Optional when **type** is `classifier`. Not valid when creating any other
               type of enrichment.
        :param str url: (optional) A URL that uses the SSL protocol (begins with
               https) for the webhook. Required when type is `webhook`. Not valid when
               creating any other type of enrichment.
        :param str version: (optional) The Discovery API version that allows to
               distinguish the schema. The version is specified in the `yyyy-mm-dd`
               format. Optional when `type` is `webhook`. Not valid when creating any
               other type of enrichment.
        :param str secret: (optional) A private key can be included in the request
               to authenticate with the external service. The maximum length is 1,024
               characters. Optional when `type` is `webhook`. Not valid when creating any
               other type of enrichment.
        :param WebhookHeader headers_: (optional) An array of headers to pass with
               the HTTP request. Optional when `type` is `webhook`. Not valid when
               creating any other type of enrichment.
        :param str location_encoding: (optional) Discovery calculates offsets of
               the text's location with this encoding type in documents. Use the same
               location encoding type in both Discovery and external enrichment for a
               document.
                These encoding types are supported: `utf-8`, `utf-16`, and `utf-32`.
               Optional when `type` is `webhook`. Not valid when creating any other type
               of enrichment.
        """
        self.languages = languages
        self.entity_type = entity_type
        self.regular_expression = regular_expression
        self.result_field = result_field
        self.classifier_id = classifier_id
        self.model_id = model_id
        self.confidence_threshold = confidence_threshold
        self.top_k = top_k
        self.url = url
        self.version = version
        self.secret = secret
        self.headers_ = headers_
        self.location_encoding = location_encoding

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'EnrichmentOptions':
        """Initialize a EnrichmentOptions object from a json dictionary."""
        args = {}
        if (languages := _dict.get('languages')) is not None:
            args['languages'] = languages
        if (entity_type := _dict.get('entity_type')) is not None:
            args['entity_type'] = entity_type
        if (regular_expression := _dict.get('regular_expression')) is not None:
            args['regular_expression'] = regular_expression
        if (result_field := _dict.get('result_field')) is not None:
            args['result_field'] = result_field
        if (classifier_id := _dict.get('classifier_id')) is not None:
            args['classifier_id'] = classifier_id
        if (model_id := _dict.get('model_id')) is not None:
            args['model_id'] = model_id
        if (confidence_threshold :=
                _dict.get('confidence_threshold')) is not None:
            args['confidence_threshold'] = confidence_threshold
        if (top_k := _dict.get('top_k')) is not None:
            args['top_k'] = top_k
        if (url := _dict.get('url')) is not None:
            args['url'] = url
        if (version := _dict.get('version')) is not None:
            args['version'] = version
        if (secret := _dict.get('secret')) is not None:
            args['secret'] = secret
        if (headers_ := _dict.get('headers')) is not None:
            args['headers_'] = WebhookHeader.from_dict(headers_)
        if (location_encoding := _dict.get('location_encoding')) is not None:
            args['location_encoding'] = location_encoding
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a EnrichmentOptions object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'languages') and self.languages is not None:
            _dict['languages'] = self.languages
        if hasattr(self, 'entity_type') and self.entity_type is not None:
            _dict['entity_type'] = self.entity_type
        if hasattr(
                self,
                'regular_expression') and self.regular_expression is not None:
            _dict['regular_expression'] = self.regular_expression
        if hasattr(self, 'result_field') and self.result_field is not None:
            _dict['result_field'] = self.result_field
        if hasattr(self, 'classifier_id') and self.classifier_id is not None:
            _dict['classifier_id'] = self.classifier_id
        if hasattr(self, 'model_id') and self.model_id is not None:
            _dict['model_id'] = self.model_id
        if hasattr(self, 'confidence_threshold'
                  ) and self.confidence_threshold is not None:
            _dict['confidence_threshold'] = self.confidence_threshold
        if hasattr(self, 'top_k') and self.top_k is not None:
            _dict['top_k'] = self.top_k
        if hasattr(self, 'url') and self.url is not None:
            _dict['url'] = self.url
        if hasattr(self, 'version') and self.version is not None:
            _dict['version'] = self.version
        if hasattr(self, 'secret') and self.secret is not None:
            _dict['secret'] = self.secret
        if hasattr(self, 'headers_') and self.headers_ is not None:
            if isinstance(self.headers_, dict):
                _dict['headers'] = self.headers_
            else:
                _dict['headers'] = self.headers_.to_dict()
        if hasattr(self,
                   'location_encoding') and self.location_encoding is not None:
            _dict['location_encoding'] = self.location_encoding
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this EnrichmentOptions object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'EnrichmentOptions') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'EnrichmentOptions') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Enrichments:
    """
    An object that contains an array of enrichment definitions.

    :param List[Enrichment] enrichments: (optional) An array of enrichment
          definitions.
    """

    def __init__(
        self,
        *,
        enrichments: Optional[List['Enrichment']] = None,
    ) -> None:
        """
        Initialize a Enrichments object.

        :param List[Enrichment] enrichments: (optional) An array of enrichment
               definitions.
        """
        self.enrichments = enrichments

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Enrichments':
        """Initialize a Enrichments object from a json dictionary."""
        args = {}
        if (enrichments := _dict.get('enrichments')) is not None:
            args['enrichments'] = [Enrichment.from_dict(v) for v in enrichments]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Enrichments object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enrichments') and self.enrichments is not None:
            enrichments_list = []
            for v in self.enrichments:
                if isinstance(v, dict):
                    enrichments_list.append(v)
                else:
                    enrichments_list.append(v.to_dict())
            _dict['enrichments'] = enrichments_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Enrichments object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Enrichments') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Enrichments') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Expansion:
    """
    An expansion definition. Each object respresents one set of expandable strings. For
    example, you could have expansions for the word `hot` in one object, and expansions
    for the word `cold` in another. Follow these guidelines when you add terms:
    * Specify the terms in lowercase. Lowercase terms expand to uppercase.
    * Multiword terms are supported only in bidirectional expansions.
    * Do not specify a term that is specified in the stop words list for the collection.

    :param List[str] input_terms: (optional) A list of terms that will be expanded
          for this expansion. If specified, only the items in this list are expanded.
    :param List[str] expanded_terms: A list of terms that this expansion will be
          expanded to. If specified without **input_terms**, the list also functions as
          the input term list.
    """

    def __init__(
        self,
        expanded_terms: List[str],
        *,
        input_terms: Optional[List[str]] = None,
    ) -> None:
        """
        Initialize a Expansion object.

        :param List[str] expanded_terms: A list of terms that this expansion will
               be expanded to. If specified without **input_terms**, the list also
               functions as the input term list.
        :param List[str] input_terms: (optional) A list of terms that will be
               expanded for this expansion. If specified, only the items in this list are
               expanded.
        """
        self.input_terms = input_terms
        self.expanded_terms = expanded_terms

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Expansion':
        """Initialize a Expansion object from a json dictionary."""
        args = {}
        if (input_terms := _dict.get('input_terms')) is not None:
            args['input_terms'] = input_terms
        if (expanded_terms := _dict.get('expanded_terms')) is not None:
            args['expanded_terms'] = expanded_terms
        else:
            raise ValueError(
                'Required property \'expanded_terms\' not present in Expansion JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Expansion object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'input_terms') and self.input_terms is not None:
            _dict['input_terms'] = self.input_terms
        if hasattr(self, 'expanded_terms') and self.expanded_terms is not None:
            _dict['expanded_terms'] = self.expanded_terms
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Expansion object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Expansion') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Expansion') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Expansions:
    """
    The query expansion definitions for the specified collection.

    :param List[Expansion] expansions: An array of query expansion definitions.
           Each object in the **expansions** array represents a term or set of terms that
          will be expanded into other terms. Each expansion object can be configured as
          `bidirectional` or `unidirectional`.
          * **Bidirectional**: Each entry in the `expanded_terms` list expands to include
          all expanded terms. For example, a query for `ibm` expands to `ibm OR
          international business machines OR big blue`.
          * **Unidirectional**: The terms in `input_terms` in the query are replaced by
          the terms in `expanded_terms`. For example, a query for the often misused term
          `on premise` is converted to `on premises OR on-premises` and does not contain
          the original term. If you want an input term to be included in the query, then
          repeat the input term in the expanded terms list.
    """

    def __init__(
        self,
        expansions: List['Expansion'],
    ) -> None:
        """
        Initialize a Expansions object.

        :param List[Expansion] expansions: An array of query expansion definitions.
                Each object in the **expansions** array represents a term or set of terms
               that will be expanded into other terms. Each expansion object can be
               configured as `bidirectional` or `unidirectional`.
               * **Bidirectional**: Each entry in the `expanded_terms` list expands to
               include all expanded terms. For example, a query for `ibm` expands to `ibm
               OR international business machines OR big blue`.
               * **Unidirectional**: The terms in `input_terms` in the query are replaced
               by the terms in `expanded_terms`. For example, a query for the often
               misused term `on premise` is converted to `on premises OR on-premises` and
               does not contain the original term. If you want an input term to be
               included in the query, then repeat the input term in the expanded terms
               list.
        """
        self.expansions = expansions

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Expansions':
        """Initialize a Expansions object from a json dictionary."""
        args = {}
        if (expansions := _dict.get('expansions')) is not None:
            args['expansions'] = [Expansion.from_dict(v) for v in expansions]
        else:
            raise ValueError(
                'Required property \'expansions\' not present in Expansions JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Expansions object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'expansions') and self.expansions is not None:
            expansions_list = []
            for v in self.expansions:
                if isinstance(v, dict):
                    expansions_list.append(v)
                else:
                    expansions_list.append(v.to_dict())
            _dict['expansions'] = expansions_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Expansions object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Expansions') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Expansions') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Field:
    """
    Object that contains field details.

    :param str field: (optional) The name of the field.
    :param str type: (optional) The type of the field.
    :param str collection_id: (optional) The collection Id of the collection where
          the field was found.
    """

    def __init__(
        self,
        *,
        field: Optional[str] = None,
        type: Optional[str] = None,
        collection_id: Optional[str] = None,
    ) -> None:
        """
        Initialize a Field object.

        """
        self.field = field
        self.type = type
        self.collection_id = collection_id

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Field':
        """Initialize a Field object from a json dictionary."""
        args = {}
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Field object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'field') and getattr(self, 'field') is not None:
            _dict['field'] = getattr(self, 'field')
        if hasattr(self, 'type') and getattr(self, 'type') is not None:
            _dict['type'] = getattr(self, 'type')
        if hasattr(self, 'collection_id') and getattr(
                self, 'collection_id') is not None:
            _dict['collection_id'] = getattr(self, 'collection_id')
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Field object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Field') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Field') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class TypeEnum(str, Enum):
        """
        The type of the field.
        """

        NESTED = 'nested'
        STRING = 'string'
        DATE = 'date'
        LONG = 'long'
        INTEGER = 'integer'
        SHORT = 'short'
        BYTE = 'byte'
        DOUBLE = 'double'
        FLOAT = 'float'
        BOOLEAN = 'boolean'
        BINARY = 'binary'


class ListBatchesResponse:
    """
    An object that contains a list of batches that are ready for enrichment by the
    external application.

    :param List[BatchDetails] batches: (optional) An array that lists the batches in
          a collection.
    """

    def __init__(
        self,
        *,
        batches: Optional[List['BatchDetails']] = None,
    ) -> None:
        """
        Initialize a ListBatchesResponse object.

        :param List[BatchDetails] batches: (optional) An array that lists the
               batches in a collection.
        """
        self.batches = batches

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ListBatchesResponse':
        """Initialize a ListBatchesResponse object from a json dictionary."""
        args = {}
        if (batches := _dict.get('batches')) is not None:
            args['batches'] = [BatchDetails.from_dict(v) for v in batches]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ListBatchesResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'batches') and self.batches is not None:
            batches_list = []
            for v in self.batches:
                if isinstance(v, dict):
                    batches_list.append(v)
                else:
                    batches_list.append(v.to_dict())
            _dict['batches'] = batches_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ListBatchesResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ListBatchesResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ListBatchesResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ListCollectionsResponse:
    """
    Response object that contains an array of collection details.

    :param List[Collection] collections: (optional) An array that contains
          information about each collection in the project.
    """

    def __init__(
        self,
        *,
        collections: Optional[List['Collection']] = None,
    ) -> None:
        """
        Initialize a ListCollectionsResponse object.

        :param List[Collection] collections: (optional) An array that contains
               information about each collection in the project.
        """
        self.collections = collections

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ListCollectionsResponse':
        """Initialize a ListCollectionsResponse object from a json dictionary."""
        args = {}
        if (collections := _dict.get('collections')) is not None:
            args['collections'] = [Collection.from_dict(v) for v in collections]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ListCollectionsResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'collections') and self.collections is not None:
            collections_list = []
            for v in self.collections:
                if isinstance(v, dict):
                    collections_list.append(v)
                else:
                    collections_list.append(v.to_dict())
            _dict['collections'] = collections_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ListCollectionsResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ListCollectionsResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ListCollectionsResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ListDocumentsResponse:
    """
    Response object that contains an array of documents.

    :param int matching_results: (optional) The number of matching results for the
          document query.
    :param List[DocumentDetails] documents: (optional) An array that lists the
          documents in a collection. Only the document ID of each document is returned in
          the list. You can use the [Get document](#getdocument) method to get more
          information about an individual document.
    """

    def __init__(
        self,
        *,
        matching_results: Optional[int] = None,
        documents: Optional[List['DocumentDetails']] = None,
    ) -> None:
        """
        Initialize a ListDocumentsResponse object.

        :param int matching_results: (optional) The number of matching results for
               the document query.
        :param List[DocumentDetails] documents: (optional) An array that lists the
               documents in a collection. Only the document ID of each document is
               returned in the list. You can use the [Get document](#getdocument) method
               to get more information about an individual document.
        """
        self.matching_results = matching_results
        self.documents = documents

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ListDocumentsResponse':
        """Initialize a ListDocumentsResponse object from a json dictionary."""
        args = {}
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        if (documents := _dict.get('documents')) is not None:
            args['documents'] = [
                DocumentDetails.from_dict(v) for v in documents
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ListDocumentsResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'documents') and self.documents is not None:
            documents_list = []
            for v in self.documents:
                if isinstance(v, dict):
                    documents_list.append(v)
                else:
                    documents_list.append(v.to_dict())
            _dict['documents'] = documents_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ListDocumentsResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ListDocumentsResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ListDocumentsResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ListFieldsResponse:
    """
    The list of fetched fields.
    The fields are returned using a fully qualified name format, however, the format
    differs slightly from that used by the query operations.
      * Fields which contain nested objects are assigned a type of "nested".
      * Fields which belong to a nested object are prefixed with `.properties` (for
    example, `warnings.properties.severity` means that the `warnings` object has a
    property called `severity`).

    :param List[Field] fields: (optional) An array that contains information about
          each field in the collections.
    """

    def __init__(
        self,
        *,
        fields: Optional[List['Field']] = None,
    ) -> None:
        """
        Initialize a ListFieldsResponse object.

        :param List[Field] fields: (optional) An array that contains information
               about each field in the collections.
        """
        self.fields = fields

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ListFieldsResponse':
        """Initialize a ListFieldsResponse object from a json dictionary."""
        args = {}
        if (fields := _dict.get('fields')) is not None:
            args['fields'] = [Field.from_dict(v) for v in fields]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ListFieldsResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'fields') and self.fields is not None:
            fields_list = []
            for v in self.fields:
                if isinstance(v, dict):
                    fields_list.append(v)
                else:
                    fields_list.append(v.to_dict())
            _dict['fields'] = fields_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ListFieldsResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ListFieldsResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ListFieldsResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ListProjectsResponse:
    """
    A list of projects in this instance.

    :param List[ProjectListDetails] projects: (optional) An array of project
          details.
    """

    def __init__(
        self,
        *,
        projects: Optional[List['ProjectListDetails']] = None,
    ) -> None:
        """
        Initialize a ListProjectsResponse object.

        :param List[ProjectListDetails] projects: (optional) An array of project
               details.
        """
        self.projects = projects

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ListProjectsResponse':
        """Initialize a ListProjectsResponse object from a json dictionary."""
        args = {}
        if (projects := _dict.get('projects')) is not None:
            args['projects'] = [
                ProjectListDetails.from_dict(v) for v in projects
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ListProjectsResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'projects') and self.projects is not None:
            projects_list = []
            for v in self.projects:
                if isinstance(v, dict):
                    projects_list.append(v)
                else:
                    projects_list.append(v.to_dict())
            _dict['projects'] = projects_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ListProjectsResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ListProjectsResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ListProjectsResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ModelEvaluationMacroAverage:
    """
    A macro-average computes metric independently for each class and then takes the
    average. Class refers to the classification label that is specified in the
    **answer_field**.

    :param float precision: A metric that measures how many of the overall documents
          are classified correctly.
    :param float recall: A metric that measures how often documents that should be
          classified into certain classes are classified into those classes.
    :param float f1: A metric that measures whether the optimal balance between
          precision and recall is reached. The F1 score can be interpreted as a weighted
          average of the precision and recall values. An F1 score reaches its best value
          at 1 and worst value at 0.
    """

    def __init__(
        self,
        precision: float,
        recall: float,
        f1: float,
    ) -> None:
        """
        Initialize a ModelEvaluationMacroAverage object.

        :param float precision: A metric that measures how many of the overall
               documents are classified correctly.
        :param float recall: A metric that measures how often documents that should
               be classified into certain classes are classified into those classes.
        :param float f1: A metric that measures whether the optimal balance between
               precision and recall is reached. The F1 score can be interpreted as a
               weighted average of the precision and recall values. An F1 score reaches
               its best value at 1 and worst value at 0.
        """
        self.precision = precision
        self.recall = recall
        self.f1 = f1

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ModelEvaluationMacroAverage':
        """Initialize a ModelEvaluationMacroAverage object from a json dictionary."""
        args = {}
        if (precision := _dict.get('precision')) is not None:
            args['precision'] = precision
        else:
            raise ValueError(
                'Required property \'precision\' not present in ModelEvaluationMacroAverage JSON'
            )
        if (recall := _dict.get('recall')) is not None:
            args['recall'] = recall
        else:
            raise ValueError(
                'Required property \'recall\' not present in ModelEvaluationMacroAverage JSON'
            )
        if (f1 := _dict.get('f1')) is not None:
            args['f1'] = f1
        else:
            raise ValueError(
                'Required property \'f1\' not present in ModelEvaluationMacroAverage JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ModelEvaluationMacroAverage object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'precision') and self.precision is not None:
            _dict['precision'] = self.precision
        if hasattr(self, 'recall') and self.recall is not None:
            _dict['recall'] = self.recall
        if hasattr(self, 'f1') and self.f1 is not None:
            _dict['f1'] = self.f1
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ModelEvaluationMacroAverage object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ModelEvaluationMacroAverage') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ModelEvaluationMacroAverage') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ModelEvaluationMicroAverage:
    """
    A micro-average aggregates the contributions of all classes to compute the average
    metric. Classes refers to the classification labels that are specified in the
    **answer_field**.

    :param float precision: A metric that measures how many of the overall documents
          are classified correctly.
    :param float recall: A metric that measures how often documents that should be
          classified into certain classes are classified into those classes.
    :param float f1: A metric that measures whether the optimal balance between
          precision and recall is reached. The F1 score can be interpreted as a weighted
          average of the precision and recall values. An F1 score reaches its best value
          at 1 and worst value at 0.
    """

    def __init__(
        self,
        precision: float,
        recall: float,
        f1: float,
    ) -> None:
        """
        Initialize a ModelEvaluationMicroAverage object.

        :param float precision: A metric that measures how many of the overall
               documents are classified correctly.
        :param float recall: A metric that measures how often documents that should
               be classified into certain classes are classified into those classes.
        :param float f1: A metric that measures whether the optimal balance between
               precision and recall is reached. The F1 score can be interpreted as a
               weighted average of the precision and recall values. An F1 score reaches
               its best value at 1 and worst value at 0.
        """
        self.precision = precision
        self.recall = recall
        self.f1 = f1

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ModelEvaluationMicroAverage':
        """Initialize a ModelEvaluationMicroAverage object from a json dictionary."""
        args = {}
        if (precision := _dict.get('precision')) is not None:
            args['precision'] = precision
        else:
            raise ValueError(
                'Required property \'precision\' not present in ModelEvaluationMicroAverage JSON'
            )
        if (recall := _dict.get('recall')) is not None:
            args['recall'] = recall
        else:
            raise ValueError(
                'Required property \'recall\' not present in ModelEvaluationMicroAverage JSON'
            )
        if (f1 := _dict.get('f1')) is not None:
            args['f1'] = f1
        else:
            raise ValueError(
                'Required property \'f1\' not present in ModelEvaluationMicroAverage JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ModelEvaluationMicroAverage object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'precision') and self.precision is not None:
            _dict['precision'] = self.precision
        if hasattr(self, 'recall') and self.recall is not None:
            _dict['recall'] = self.recall
        if hasattr(self, 'f1') and self.f1 is not None:
            _dict['f1'] = self.f1
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ModelEvaluationMicroAverage object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ModelEvaluationMicroAverage') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ModelEvaluationMicroAverage') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class Notice:
    """
    A notice produced for the collection.

    :param str notice_id: (optional) Identifies the notice. Many notices might have
          the same ID. This field exists so that user applications can programmatically
          identify a notice and take automatic corrective action. Typical notice IDs
          include:
          `index_failed`, `index_failed_too_many_requests`,
          `index_failed_incompatible_field`, `index_failed_cluster_unavailable`,
          `ingestion_timeout`, `ingestion_error`, `bad_request`, `internal_error`,
          `missing_model`, `unsupported_model`,
          `smart_document_understanding_failed_incompatible_field`,
          `smart_document_understanding_failed_internal_error`,
          `smart_document_understanding_failed_internal_error`,
          `smart_document_understanding_failed_warning`,
          `smart_document_understanding_page_error`,
          `smart_document_understanding_page_warning`. **Note:** This is not a complete
          list. Other values might be returned.
    :param datetime created: (optional) The creation date of the collection in the
          format yyyy-MM-dd'T'HH:mm:ss.SSS'Z'.
    :param str document_id: (optional) Unique identifier of the document.
    :param str collection_id: (optional) Unique identifier of the collection.
    :param str query_id: (optional) Unique identifier of the query used for
          relevance training.
    :param str severity: (optional) Severity level of the notice.
    :param str step: (optional) Ingestion or training step in which the notice
          occurred.
    :param str description: (optional) The description of the notice.
    """

    def __init__(
        self,
        *,
        notice_id: Optional[str] = None,
        created: Optional[datetime] = None,
        document_id: Optional[str] = None,
        collection_id: Optional[str] = None,
        query_id: Optional[str] = None,
        severity: Optional[str] = None,
        step: Optional[str] = None,
        description: Optional[str] = None,
    ) -> None:
        """
        Initialize a Notice object.

        """
        self.notice_id = notice_id
        self.created = created
        self.document_id = document_id
        self.collection_id = collection_id
        self.query_id = query_id
        self.severity = severity
        self.step = step
        self.description = description

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'Notice':
        """Initialize a Notice object from a json dictionary."""
        args = {}
        if (notice_id := _dict.get('notice_id')) is not None:
            args['notice_id'] = notice_id
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        if (query_id := _dict.get('query_id')) is not None:
            args['query_id'] = query_id
        if (severity := _dict.get('severity')) is not None:
            args['severity'] = severity
        if (step := _dict.get('step')) is not None:
            args['step'] = step
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a Notice object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'notice_id') and getattr(self,
                                                  'notice_id') is not None:
            _dict['notice_id'] = getattr(self, 'notice_id')
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'document_id') and getattr(self,
                                                    'document_id') is not None:
            _dict['document_id'] = getattr(self, 'document_id')
        if hasattr(self, 'collection_id') and getattr(
                self, 'collection_id') is not None:
            _dict['collection_id'] = getattr(self, 'collection_id')
        if hasattr(self, 'query_id') and getattr(self, 'query_id') is not None:
            _dict['query_id'] = getattr(self, 'query_id')
        if hasattr(self, 'severity') and getattr(self, 'severity') is not None:
            _dict['severity'] = getattr(self, 'severity')
        if hasattr(self, 'step') and getattr(self, 'step') is not None:
            _dict['step'] = getattr(self, 'step')
        if hasattr(self, 'description') and getattr(self,
                                                    'description') is not None:
            _dict['description'] = getattr(self, 'description')
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this Notice object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'Notice') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'Notice') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class SeverityEnum(str, Enum):
        """
        Severity level of the notice.
        """

        WARNING = 'warning'
        ERROR = 'error'


class PerClassModelEvaluation:
    """
    An object that measures the metrics from a training run for each classification label
    separately.

    :param str name: Class name. Each class name is derived from a value in the
          **answer_field**.
    :param float precision: A metric that measures how many of the overall documents
          are classified correctly.
    :param float recall: A metric that measures how often documents that should be
          classified into certain classes are classified into those classes.
    :param float f1: A metric that measures whether the optimal balance between
          precision and recall is reached. The F1 score can be interpreted as a weighted
          average of the precision and recall values. An F1 score reaches its best value
          at 1 and worst value at 0.
    """

    def __init__(
        self,
        name: str,
        precision: float,
        recall: float,
        f1: float,
    ) -> None:
        """
        Initialize a PerClassModelEvaluation object.

        :param str name: Class name. Each class name is derived from a value in the
               **answer_field**.
        :param float precision: A metric that measures how many of the overall
               documents are classified correctly.
        :param float recall: A metric that measures how often documents that should
               be classified into certain classes are classified into those classes.
        :param float f1: A metric that measures whether the optimal balance between
               precision and recall is reached. The F1 score can be interpreted as a
               weighted average of the precision and recall values. An F1 score reaches
               its best value at 1 and worst value at 0.
        """
        self.name = name
        self.precision = precision
        self.recall = recall
        self.f1 = f1

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'PerClassModelEvaluation':
        """Initialize a PerClassModelEvaluation object from a json dictionary."""
        args = {}
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        else:
            raise ValueError(
                'Required property \'name\' not present in PerClassModelEvaluation JSON'
            )
        if (precision := _dict.get('precision')) is not None:
            args['precision'] = precision
        else:
            raise ValueError(
                'Required property \'precision\' not present in PerClassModelEvaluation JSON'
            )
        if (recall := _dict.get('recall')) is not None:
            args['recall'] = recall
        else:
            raise ValueError(
                'Required property \'recall\' not present in PerClassModelEvaluation JSON'
            )
        if (f1 := _dict.get('f1')) is not None:
            args['f1'] = f1
        else:
            raise ValueError(
                'Required property \'f1\' not present in PerClassModelEvaluation JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a PerClassModelEvaluation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'precision') and self.precision is not None:
            _dict['precision'] = self.precision
        if hasattr(self, 'recall') and self.recall is not None:
            _dict['recall'] = self.recall
        if hasattr(self, 'f1') and self.f1 is not None:
            _dict['f1'] = self.f1
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this PerClassModelEvaluation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'PerClassModelEvaluation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'PerClassModelEvaluation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ProjectDetails:
    """
    Detailed information about the specified project.

    :param str project_id: (optional) The Universally Unique Identifier (UUID) of
          this project.
    :param str name: (optional) The human readable name of this project.
    :param str type: (optional) The type of project.
          The `content_intelligence` type is a *Document Retrieval for Contracts* project
          and the `other` type is a *Custom* project.
          The `content_mining` and `content_intelligence` types are available with Premium
          plan managed deployments and installed deployments only.
          The Intelligent Document Processing (IDP) project type is available from IBM
          Cloud-managed instances only.
    :param ProjectListDetailsRelevancyTrainingStatus relevancy_training_status:
          (optional) Relevancy training status information for this project.
    :param int collection_count: (optional) The number of collections configured in
          this project.
    :param DefaultQueryParams default_query_parameters: (optional) Default query
          parameters for this project.
    """

    def __init__(
        self,
        *,
        project_id: Optional[str] = None,
        name: Optional[str] = None,
        type: Optional[str] = None,
        relevancy_training_status: Optional[
            'ProjectListDetailsRelevancyTrainingStatus'] = None,
        collection_count: Optional[int] = None,
        default_query_parameters: Optional['DefaultQueryParams'] = None,
    ) -> None:
        """
        Initialize a ProjectDetails object.

        :param str name: (optional) The human readable name of this project.
        :param str type: (optional) The type of project.
               The `content_intelligence` type is a *Document Retrieval for Contracts*
               project and the `other` type is a *Custom* project.
               The `content_mining` and `content_intelligence` types are available with
               Premium plan managed deployments and installed deployments only.
               The Intelligent Document Processing (IDP) project type is available from
               IBM Cloud-managed instances only.
        :param DefaultQueryParams default_query_parameters: (optional) Default
               query parameters for this project.
        """
        self.project_id = project_id
        self.name = name
        self.type = type
        self.relevancy_training_status = relevancy_training_status
        self.collection_count = collection_count
        self.default_query_parameters = default_query_parameters

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ProjectDetails':
        """Initialize a ProjectDetails object from a json dictionary."""
        args = {}
        if (project_id := _dict.get('project_id')) is not None:
            args['project_id'] = project_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (relevancy_training_status :=
                _dict.get('relevancy_training_status')) is not None:
            args[
                'relevancy_training_status'] = ProjectListDetailsRelevancyTrainingStatus.from_dict(
                    relevancy_training_status)
        if (collection_count := _dict.get('collection_count')) is not None:
            args['collection_count'] = collection_count
        if (default_query_parameters :=
                _dict.get('default_query_parameters')) is not None:
            args['default_query_parameters'] = DefaultQueryParams.from_dict(
                default_query_parameters)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ProjectDetails object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'project_id') and getattr(self,
                                                   'project_id') is not None:
            _dict['project_id'] = getattr(self, 'project_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'relevancy_training_status') and getattr(
                self, 'relevancy_training_status') is not None:
            if isinstance(getattr(self, 'relevancy_training_status'), dict):
                _dict['relevancy_training_status'] = getattr(
                    self, 'relevancy_training_status')
            else:
                _dict['relevancy_training_status'] = getattr(
                    self, 'relevancy_training_status').to_dict()
        if hasattr(self, 'collection_count') and getattr(
                self, 'collection_count') is not None:
            _dict['collection_count'] = getattr(self, 'collection_count')
        if hasattr(self, 'default_query_parameters'
                  ) and self.default_query_parameters is not None:
            if isinstance(self.default_query_parameters, dict):
                _dict[
                    'default_query_parameters'] = self.default_query_parameters
            else:
                _dict[
                    'default_query_parameters'] = self.default_query_parameters.to_dict(
                    )
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ProjectDetails object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ProjectDetails') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ProjectDetails') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class TypeEnum(str, Enum):
        """
        The type of project.
        The `content_intelligence` type is a *Document Retrieval for Contracts* project
        and the `other` type is a *Custom* project.
        The `content_mining` and `content_intelligence` types are available with Premium
        plan managed deployments and installed deployments only.
        The Intelligent Document Processing (IDP) project type is available from IBM
        Cloud-managed instances only.
        """

        INTELLIGENT_DOCUMENT_PROCESSING = 'intelligent_document_processing'
        DOCUMENT_RETRIEVAL = 'document_retrieval'
        CONVERSATIONAL_SEARCH = 'conversational_search'
        CONTENT_MINING = 'content_mining'
        CONTENT_INTELLIGENCE = 'content_intelligence'
        OTHER = 'other'


class ProjectListDetails:
    """
    Details about a specific project.

    :param str project_id: (optional) The Universally Unique Identifier (UUID) of
          this project.
    :param str name: (optional) The human readable name of this project.
    :param str type: (optional) The type of project.
          The `content_intelligence` type is a *Document Retrieval for Contracts* project
          and the `other` type is a *Custom* project.
          The `content_mining` and `content_intelligence` types are available with Premium
          plan managed deployments and installed deployments only.
          The Intelligent Document Processing (IDP) project type is available from IBM
          Cloud-managed instances only.
    :param ProjectListDetailsRelevancyTrainingStatus relevancy_training_status:
          (optional) Relevancy training status information for this project.
    :param int collection_count: (optional) The number of collections configured in
          this project.
    """

    def __init__(
        self,
        *,
        project_id: Optional[str] = None,
        name: Optional[str] = None,
        type: Optional[str] = None,
        relevancy_training_status: Optional[
            'ProjectListDetailsRelevancyTrainingStatus'] = None,
        collection_count: Optional[int] = None,
    ) -> None:
        """
        Initialize a ProjectListDetails object.

        :param str name: (optional) The human readable name of this project.
        :param str type: (optional) The type of project.
               The `content_intelligence` type is a *Document Retrieval for Contracts*
               project and the `other` type is a *Custom* project.
               The `content_mining` and `content_intelligence` types are available with
               Premium plan managed deployments and installed deployments only.
               The Intelligent Document Processing (IDP) project type is available from
               IBM Cloud-managed instances only.
        """
        self.project_id = project_id
        self.name = name
        self.type = type
        self.relevancy_training_status = relevancy_training_status
        self.collection_count = collection_count

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ProjectListDetails':
        """Initialize a ProjectListDetails object from a json dictionary."""
        args = {}
        if (project_id := _dict.get('project_id')) is not None:
            args['project_id'] = project_id
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (relevancy_training_status :=
                _dict.get('relevancy_training_status')) is not None:
            args[
                'relevancy_training_status'] = ProjectListDetailsRelevancyTrainingStatus.from_dict(
                    relevancy_training_status)
        if (collection_count := _dict.get('collection_count')) is not None:
            args['collection_count'] = collection_count
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ProjectListDetails object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'project_id') and getattr(self,
                                                   'project_id') is not None:
            _dict['project_id'] = getattr(self, 'project_id')
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'relevancy_training_status') and getattr(
                self, 'relevancy_training_status') is not None:
            if isinstance(getattr(self, 'relevancy_training_status'), dict):
                _dict['relevancy_training_status'] = getattr(
                    self, 'relevancy_training_status')
            else:
                _dict['relevancy_training_status'] = getattr(
                    self, 'relevancy_training_status').to_dict()
        if hasattr(self, 'collection_count') and getattr(
                self, 'collection_count') is not None:
            _dict['collection_count'] = getattr(self, 'collection_count')
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ProjectListDetails object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ProjectListDetails') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ProjectListDetails') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class TypeEnum(str, Enum):
        """
        The type of project.
        The `content_intelligence` type is a *Document Retrieval for Contracts* project
        and the `other` type is a *Custom* project.
        The `content_mining` and `content_intelligence` types are available with Premium
        plan managed deployments and installed deployments only.
        The Intelligent Document Processing (IDP) project type is available from IBM
        Cloud-managed instances only.
        """

        INTELLIGENT_DOCUMENT_PROCESSING = 'intelligent_document_processing'
        DOCUMENT_RETRIEVAL = 'document_retrieval'
        CONVERSATIONAL_SEARCH = 'conversational_search'
        CONTENT_MINING = 'content_mining'
        CONTENT_INTELLIGENCE = 'content_intelligence'
        OTHER = 'other'


class ProjectListDetailsRelevancyTrainingStatus:
    """
    Relevancy training status information for this project.

    :param str data_updated: (optional) When the training data was updated.
    :param int total_examples: (optional) The total number of examples.
    :param bool sufficient_label_diversity: (optional) When `true`, sufficient label
          diversity is present to allow training for this project.
    :param bool processing: (optional) When `true`, the relevancy training is in
          processing.
    :param bool minimum_examples_added: (optional) When `true`, the minimum number
          of examples required to train has been met.
    :param str successfully_trained: (optional) The time that the most recent
          successful training occurred.
    :param bool available: (optional) When `true`, relevancy training is available
          when querying collections in the project.
    :param int notices: (optional) The number of notices generated during the
          relevancy training.
    :param bool minimum_queries_added: (optional) When `true`, the minimum number of
          queries required to train has been met.
    """

    def __init__(
        self,
        *,
        data_updated: Optional[str] = None,
        total_examples: Optional[int] = None,
        sufficient_label_diversity: Optional[bool] = None,
        processing: Optional[bool] = None,
        minimum_examples_added: Optional[bool] = None,
        successfully_trained: Optional[str] = None,
        available: Optional[bool] = None,
        notices: Optional[int] = None,
        minimum_queries_added: Optional[bool] = None,
    ) -> None:
        """
        Initialize a ProjectListDetailsRelevancyTrainingStatus object.

        :param str data_updated: (optional) When the training data was updated.
        :param int total_examples: (optional) The total number of examples.
        :param bool sufficient_label_diversity: (optional) When `true`, sufficient
               label diversity is present to allow training for this project.
        :param bool processing: (optional) When `true`, the relevancy training is
               in processing.
        :param bool minimum_examples_added: (optional) When `true`, the minimum
               number of examples required to train has been met.
        :param str successfully_trained: (optional) The time that the most recent
               successful training occurred.
        :param bool available: (optional) When `true`, relevancy training is
               available when querying collections in the project.
        :param int notices: (optional) The number of notices generated during the
               relevancy training.
        :param bool minimum_queries_added: (optional) When `true`, the minimum
               number of queries required to train has been met.
        """
        self.data_updated = data_updated
        self.total_examples = total_examples
        self.sufficient_label_diversity = sufficient_label_diversity
        self.processing = processing
        self.minimum_examples_added = minimum_examples_added
        self.successfully_trained = successfully_trained
        self.available = available
        self.notices = notices
        self.minimum_queries_added = minimum_queries_added

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'ProjectListDetailsRelevancyTrainingStatus':
        """Initialize a ProjectListDetailsRelevancyTrainingStatus object from a json dictionary."""
        args = {}
        if (data_updated := _dict.get('data_updated')) is not None:
            args['data_updated'] = data_updated
        if (total_examples := _dict.get('total_examples')) is not None:
            args['total_examples'] = total_examples
        if (sufficient_label_diversity :=
                _dict.get('sufficient_label_diversity')) is not None:
            args['sufficient_label_diversity'] = sufficient_label_diversity
        if (processing := _dict.get('processing')) is not None:
            args['processing'] = processing
        if (minimum_examples_added :=
                _dict.get('minimum_examples_added')) is not None:
            args['minimum_examples_added'] = minimum_examples_added
        if (successfully_trained :=
                _dict.get('successfully_trained')) is not None:
            args['successfully_trained'] = successfully_trained
        if (available := _dict.get('available')) is not None:
            args['available'] = available
        if (notices := _dict.get('notices')) is not None:
            args['notices'] = notices
        if (minimum_queries_added :=
                _dict.get('minimum_queries_added')) is not None:
            args['minimum_queries_added'] = minimum_queries_added
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ProjectListDetailsRelevancyTrainingStatus object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'data_updated') and self.data_updated is not None:
            _dict['data_updated'] = self.data_updated
        if hasattr(self, 'total_examples') and self.total_examples is not None:
            _dict['total_examples'] = self.total_examples
        if hasattr(self, 'sufficient_label_diversity'
                  ) and self.sufficient_label_diversity is not None:
            _dict[
                'sufficient_label_diversity'] = self.sufficient_label_diversity
        if hasattr(self, 'processing') and self.processing is not None:
            _dict['processing'] = self.processing
        if hasattr(self, 'minimum_examples_added'
                  ) and self.minimum_examples_added is not None:
            _dict['minimum_examples_added'] = self.minimum_examples_added
        if hasattr(self, 'successfully_trained'
                  ) and self.successfully_trained is not None:
            _dict['successfully_trained'] = self.successfully_trained
        if hasattr(self, 'available') and self.available is not None:
            _dict['available'] = self.available
        if hasattr(self, 'notices') and self.notices is not None:
            _dict['notices'] = self.notices
        if hasattr(self, 'minimum_queries_added'
                  ) and self.minimum_queries_added is not None:
            _dict['minimum_queries_added'] = self.minimum_queries_added
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ProjectListDetailsRelevancyTrainingStatus object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self,
               other: 'ProjectListDetailsRelevancyTrainingStatus') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self,
               other: 'ProjectListDetailsRelevancyTrainingStatus') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregation:
    """
    An object that defines how to aggregate query results.

    """

    def __init__(self,) -> None:
        """
        Initialize a QueryAggregation object.

        """
        msg = "Cannot instantiate base class. Instead, instantiate one of the defined subclasses: {0}".format(
            ", ".join([
                'QueryAggregationQueryTermAggregation',
                'QueryAggregationQueryGroupByAggregation',
                'QueryAggregationQueryHistogramAggregation',
                'QueryAggregationQueryTimesliceAggregation',
                'QueryAggregationQueryNestedAggregation',
                'QueryAggregationQueryFilterAggregation',
                'QueryAggregationQueryCalculationAggregation',
                'QueryAggregationQueryTopHitsAggregation',
                'QueryAggregationQueryPairAggregation',
                'QueryAggregationQueryTrendAggregation',
                'QueryAggregationQueryTopicAggregation'
            ]))
        raise Exception(msg)

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregation':
        """Initialize a QueryAggregation object from a json dictionary."""
        disc_class = cls._get_class_by_discriminator(_dict)
        if disc_class != cls:
            return disc_class.from_dict(_dict)
        msg = "Cannot convert dictionary into an instance of base class 'QueryAggregation'. The discriminator value should map to a valid subclass: {1}".format(
            ", ".join([
                'QueryAggregationQueryTermAggregation',
                'QueryAggregationQueryGroupByAggregation',
                'QueryAggregationQueryHistogramAggregation',
                'QueryAggregationQueryTimesliceAggregation',
                'QueryAggregationQueryNestedAggregation',
                'QueryAggregationQueryFilterAggregation',
                'QueryAggregationQueryCalculationAggregation',
                'QueryAggregationQueryTopHitsAggregation',
                'QueryAggregationQueryPairAggregation',
                'QueryAggregationQueryTrendAggregation',
                'QueryAggregationQueryTopicAggregation'
            ]))
        raise Exception(msg)

    @classmethod
    def _from_dict(cls, _dict: Dict):
        """Initialize a QueryAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    @classmethod
    def _get_class_by_discriminator(cls, _dict: Dict) -> object:
        mapping = {}
        mapping['term'] = 'QueryAggregationQueryTermAggregation'
        mapping['group_by'] = 'QueryAggregationQueryGroupByAggregation'
        mapping['histogram'] = 'QueryAggregationQueryHistogramAggregation'
        mapping['timeslice'] = 'QueryAggregationQueryTimesliceAggregation'
        mapping['nested'] = 'QueryAggregationQueryNestedAggregation'
        mapping['filter'] = 'QueryAggregationQueryFilterAggregation'
        mapping['min'] = 'QueryAggregationQueryCalculationAggregation'
        mapping['max'] = 'QueryAggregationQueryCalculationAggregation'
        mapping['sum'] = 'QueryAggregationQueryCalculationAggregation'
        mapping['average'] = 'QueryAggregationQueryCalculationAggregation'
        mapping['unique_count'] = 'QueryAggregationQueryCalculationAggregation'
        mapping['top_hits'] = 'QueryAggregationQueryTopHitsAggregation'
        mapping['pair'] = 'QueryAggregationQueryPairAggregation'
        mapping['trend'] = 'QueryAggregationQueryTrendAggregation'
        mapping['topic'] = 'QueryAggregationQueryTopicAggregation'
        disc_value = _dict.get('type')
        if disc_value is None:
            raise ValueError(
                'Discriminator property \'type\' not found in QueryAggregation JSON'
            )
        class_name = mapping.get(disc_value, disc_value)
        try:
            disc_class = getattr(sys.modules[__name__], class_name)
        except AttributeError:
            disc_class = cls
        if isinstance(disc_class, object):
            return disc_class
        raise TypeError('%s is not a discriminator class' % class_name)


class QueryGroupByAggregationResult:
    """
    Result group for the `group_by` aggregation.

    :param str key: The condition that is met by the documents in this group. For
          example, `YEARTXT<2000`.
    :param int matching_results: Number of documents that meet the query and
          condition.
    :param float relevancy: (optional) The relevancy for this group. Returned only
          if `relevancy:true` is specified in the request.
    :param int total_matching_documents: (optional) Number of documents that meet
          the condition in the whole set of documents in this collection. Returned only
          when `relevancy:true` is specified in the request.
    :param float estimated_matching_results: (optional) The number of documents that
          are estimated to match the query and condition. Returned only when
          `relevancy:true` is specified in the request.
    :param List[dict] aggregations: (optional) An array of subaggregations. Returned
          only when this aggregation is returned as a subaggregation.
    """

    def __init__(
        self,
        key: str,
        matching_results: int,
        *,
        relevancy: Optional[float] = None,
        total_matching_documents: Optional[int] = None,
        estimated_matching_results: Optional[float] = None,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryGroupByAggregationResult object.

        :param str key: The condition that is met by the documents in this group.
               For example, `YEARTXT<2000`.
        :param int matching_results: Number of documents that meet the query and
               condition.
        :param float relevancy: (optional) The relevancy for this group. Returned
               only if `relevancy:true` is specified in the request.
        :param int total_matching_documents: (optional) Number of documents that
               meet the condition in the whole set of documents in this collection.
               Returned only when `relevancy:true` is specified in the request.
        :param float estimated_matching_results: (optional) The number of documents
               that are estimated to match the query and condition. Returned only when
               `relevancy:true` is specified in the request.
        :param List[dict] aggregations: (optional) An array of subaggregations.
               Returned only when this aggregation is returned as a subaggregation.
        """
        self.key = key
        self.matching_results = matching_results
        self.relevancy = relevancy
        self.total_matching_documents = total_matching_documents
        self.estimated_matching_results = estimated_matching_results
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryGroupByAggregationResult':
        """Initialize a QueryGroupByAggregationResult object from a json dictionary."""
        args = {}
        if (key := _dict.get('key')) is not None:
            args['key'] = key
        else:
            raise ValueError(
                'Required property \'key\' not present in QueryGroupByAggregationResult JSON'
            )
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryGroupByAggregationResult JSON'
            )
        if (relevancy := _dict.get('relevancy')) is not None:
            args['relevancy'] = relevancy
        if (total_matching_documents :=
                _dict.get('total_matching_documents')) is not None:
            args['total_matching_documents'] = total_matching_documents
        if (estimated_matching_results :=
                _dict.get('estimated_matching_results')) is not None:
            args['estimated_matching_results'] = estimated_matching_results
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryGroupByAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'key') and self.key is not None:
            _dict['key'] = self.key
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'relevancy') and self.relevancy is not None:
            _dict['relevancy'] = self.relevancy
        if hasattr(self, 'total_matching_documents'
                  ) and self.total_matching_documents is not None:
            _dict['total_matching_documents'] = self.total_matching_documents
        if hasattr(self, 'estimated_matching_results'
                  ) and self.estimated_matching_results is not None:
            _dict[
                'estimated_matching_results'] = self.estimated_matching_results
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryGroupByAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryGroupByAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryGroupByAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryHistogramAggregationResult:
    """
    Histogram numeric interval result.

    :param int key: The value of the upper bound for the numeric segment.
    :param int matching_results: Number of documents with the specified key as the
          upper bound.
    :param List[dict] aggregations: (optional) An array of subaggregations. Returned
          only when this aggregation is returned as a subaggregation.
    """

    def __init__(
        self,
        key: int,
        matching_results: int,
        *,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryHistogramAggregationResult object.

        :param int key: The value of the upper bound for the numeric segment.
        :param int matching_results: Number of documents with the specified key as
               the upper bound.
        :param List[dict] aggregations: (optional) An array of subaggregations.
               Returned only when this aggregation is returned as a subaggregation.
        """
        self.key = key
        self.matching_results = matching_results
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryHistogramAggregationResult':
        """Initialize a QueryHistogramAggregationResult object from a json dictionary."""
        args = {}
        if (key := _dict.get('key')) is not None:
            args['key'] = key
        else:
            raise ValueError(
                'Required property \'key\' not present in QueryHistogramAggregationResult JSON'
            )
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryHistogramAggregationResult JSON'
            )
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryHistogramAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'key') and self.key is not None:
            _dict['key'] = self.key
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryHistogramAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryHistogramAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryHistogramAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryLargePassages:
    """
    Configuration for passage retrieval.

    :param bool enabled: (optional) A passages query that returns the most relevant
          passages from the results.
    :param bool per_document: (optional) If `true`, ranks the documents by document
          quality, and then returns the highest-ranked passages per document in a
          `document_passages` field for each document entry in the results list of the
          response.
          If `false`, ranks the passages from all of the documents by passage quality
          regardless of the document quality and returns them in a separate `passages`
          field in the response.
    :param int max_per_document: (optional) Maximum number of passages to return per
          document in the result. Ignored if **passages.per_document** is `false`.
    :param List[str] fields: (optional) A list of fields to extract passages from.
          By default, passages are extracted from the `text` and `title` fields only. If
          you add this parameter and specify an empty list (`[]`) as its value, then the
          service searches all root-level fields for suitable passages.
    :param int count: (optional) The maximum number of passages to return. Ignored
          if **passages.per_document** is `true`.
    :param int characters: (optional) The approximate number of characters that any
          one passage will have.
    :param bool find_answers: (optional) When true, `answer` objects are returned as
          part of each passage in the query results. The primary difference between an
          `answer` and a `passage` is that the length of a passage is defined by the
          query, where the length of an `answer` is calculated by Discovery based on how
          much text is needed to answer the question.
          This parameter is ignored if passages are not enabled for the query, or no
          **natural_language_query** is specified.
          If the **find_answers** parameter is set to `true` and **per_document**
          parameter is also set to `true`, then the document search results and the
          passage search results within each document are reordered using the answer
          confidences. The goal of this reordering is to place the best answer as the
          first answer of the first passage of the first document. Similarly, if the
          **find_answers** parameter is set to `true` and **per_document** parameter is
          set to `false`, then the passage search results are reordered in decreasing
          order of the highest confidence answer for each document and passage.
          The **find_answers** parameter is available only on managed instances of
          Discovery.
    :param int max_answers_per_passage: (optional) The number of `answer` objects to
          return per passage if the **find_answers** parmeter is specified as `true`.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        per_document: Optional[bool] = None,
        max_per_document: Optional[int] = None,
        fields: Optional[List[str]] = None,
        count: Optional[int] = None,
        characters: Optional[int] = None,
        find_answers: Optional[bool] = None,
        max_answers_per_passage: Optional[int] = None,
    ) -> None:
        """
        Initialize a QueryLargePassages object.

        :param bool enabled: (optional) A passages query that returns the most
               relevant passages from the results.
        :param bool per_document: (optional) If `true`, ranks the documents by
               document quality, and then returns the highest-ranked passages per document
               in a `document_passages` field for each document entry in the results list
               of the response.
               If `false`, ranks the passages from all of the documents by passage quality
               regardless of the document quality and returns them in a separate
               `passages` field in the response.
        :param int max_per_document: (optional) Maximum number of passages to
               return per document in the result. Ignored if **passages.per_document** is
               `false`.
        :param List[str] fields: (optional) A list of fields to extract passages
               from. By default, passages are extracted from the `text` and `title` fields
               only. If you add this parameter and specify an empty list (`[]`) as its
               value, then the service searches all root-level fields for suitable
               passages.
        :param int count: (optional) The maximum number of passages to return.
               Ignored if **passages.per_document** is `true`.
        :param int characters: (optional) The approximate number of characters that
               any one passage will have.
        :param bool find_answers: (optional) When true, `answer` objects are
               returned as part of each passage in the query results. The primary
               difference between an `answer` and a `passage` is that the length of a
               passage is defined by the query, where the length of an `answer` is
               calculated by Discovery based on how much text is needed to answer the
               question.
               This parameter is ignored if passages are not enabled for the query, or no
               **natural_language_query** is specified.
               If the **find_answers** parameter is set to `true` and **per_document**
               parameter is also set to `true`, then the document search results and the
               passage search results within each document are reordered using the answer
               confidences. The goal of this reordering is to place the best answer as the
               first answer of the first passage of the first document. Similarly, if the
               **find_answers** parameter is set to `true` and **per_document** parameter
               is set to `false`, then the passage search results are reordered in
               decreasing order of the highest confidence answer for each document and
               passage.
               The **find_answers** parameter is available only on managed instances of
               Discovery.
        :param int max_answers_per_passage: (optional) The number of `answer`
               objects to return per passage if the **find_answers** parmeter is specified
               as `true`.
        """
        self.enabled = enabled
        self.per_document = per_document
        self.max_per_document = max_per_document
        self.fields = fields
        self.count = count
        self.characters = characters
        self.find_answers = find_answers
        self.max_answers_per_passage = max_answers_per_passage

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryLargePassages':
        """Initialize a QueryLargePassages object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (per_document := _dict.get('per_document')) is not None:
            args['per_document'] = per_document
        if (max_per_document := _dict.get('max_per_document')) is not None:
            args['max_per_document'] = max_per_document
        if (fields := _dict.get('fields')) is not None:
            args['fields'] = fields
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        if (characters := _dict.get('characters')) is not None:
            args['characters'] = characters
        if (find_answers := _dict.get('find_answers')) is not None:
            args['find_answers'] = find_answers
        if (max_answers_per_passage :=
                _dict.get('max_answers_per_passage')) is not None:
            args['max_answers_per_passage'] = max_answers_per_passage
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryLargePassages object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'per_document') and self.per_document is not None:
            _dict['per_document'] = self.per_document
        if hasattr(self,
                   'max_per_document') and self.max_per_document is not None:
            _dict['max_per_document'] = self.max_per_document
        if hasattr(self, 'fields') and self.fields is not None:
            _dict['fields'] = self.fields
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        if hasattr(self, 'characters') and self.characters is not None:
            _dict['characters'] = self.characters
        if hasattr(self, 'find_answers') and self.find_answers is not None:
            _dict['find_answers'] = self.find_answers
        if hasattr(self, 'max_answers_per_passage'
                  ) and self.max_answers_per_passage is not None:
            _dict['max_answers_per_passage'] = self.max_answers_per_passage
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryLargePassages object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryLargePassages') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryLargePassages') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryLargeSimilar:
    """
    Finds results from documents that are similar to documents of interest. Use this
    parameter to add a *More like these* function to your search. You can include this
    parameter with or without a **query**, **filter** or **natural_language_query**
    parameter.

    :param bool enabled: (optional) When `true`, includes documents in the query
          results that are similar to documents you specify.
    :param List[str] document_ids: (optional) The list of documents of interest.
          Required if **enabled** is `true`.
    :param List[str] fields: (optional) Looks for similarities in the specified
          subset of fields in the documents. If not specified, all of the document fields
          are used.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        document_ids: Optional[List[str]] = None,
        fields: Optional[List[str]] = None,
    ) -> None:
        """
        Initialize a QueryLargeSimilar object.

        :param bool enabled: (optional) When `true`, includes documents in the
               query results that are similar to documents you specify.
        :param List[str] document_ids: (optional) The list of documents of
               interest. Required if **enabled** is `true`.
        :param List[str] fields: (optional) Looks for similarities in the specified
               subset of fields in the documents. If not specified, all of the document
               fields are used.
        """
        self.enabled = enabled
        self.document_ids = document_ids
        self.fields = fields

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryLargeSimilar':
        """Initialize a QueryLargeSimilar object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (document_ids := _dict.get('document_ids')) is not None:
            args['document_ids'] = document_ids
        if (fields := _dict.get('fields')) is not None:
            args['fields'] = fields
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryLargeSimilar object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'document_ids') and self.document_ids is not None:
            _dict['document_ids'] = self.document_ids
        if hasattr(self, 'fields') and self.fields is not None:
            _dict['fields'] = self.fields
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryLargeSimilar object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryLargeSimilar') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryLargeSimilar') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryLargeSuggestedRefinements:
    """
    Configuration for suggested refinements.
    **Note**: The **suggested_refinements** parameter that identified dynamic facets from
    the data is deprecated.

    :param bool enabled: (optional) Whether to perform suggested refinements.
    :param int count: (optional) Maximum number of suggested refinements texts to be
          returned. The maximum is `100`.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        count: Optional[int] = None,
    ) -> None:
        """
        Initialize a QueryLargeSuggestedRefinements object.

        :param bool enabled: (optional) Whether to perform suggested refinements.
        :param int count: (optional) Maximum number of suggested refinements texts
               to be returned. The maximum is `100`.
        """
        self.enabled = enabled
        self.count = count

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryLargeSuggestedRefinements':
        """Initialize a QueryLargeSuggestedRefinements object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryLargeSuggestedRefinements object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryLargeSuggestedRefinements object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryLargeSuggestedRefinements') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryLargeSuggestedRefinements') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryLargeTableResults:
    """
    Configuration for table retrieval.

    :param bool enabled: (optional) Whether to enable table retrieval.
    :param int count: (optional) Maximum number of tables to return.
    """

    def __init__(
        self,
        *,
        enabled: Optional[bool] = None,
        count: Optional[int] = None,
    ) -> None:
        """
        Initialize a QueryLargeTableResults object.

        :param bool enabled: (optional) Whether to enable table retrieval.
        :param int count: (optional) Maximum number of tables to return.
        """
        self.enabled = enabled
        self.count = count

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryLargeTableResults':
        """Initialize a QueryLargeTableResults object from a json dictionary."""
        args = {}
        if (enabled := _dict.get('enabled')) is not None:
            args['enabled'] = enabled
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryLargeTableResults object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'enabled') and self.enabled is not None:
            _dict['enabled'] = self.enabled
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryLargeTableResults object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryLargeTableResults') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryLargeTableResults') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryNoticesResponse:
    """
    Object that contains notice query results.

    :param int matching_results: (optional) The number of matching results.
    :param List[Notice] notices: (optional) Array of document results that match the
          query.
    """

    def __init__(
        self,
        *,
        matching_results: Optional[int] = None,
        notices: Optional[List['Notice']] = None,
    ) -> None:
        """
        Initialize a QueryNoticesResponse object.

        :param int matching_results: (optional) The number of matching results.
        :param List[Notice] notices: (optional) Array of document results that
               match the query.
        """
        self.matching_results = matching_results
        self.notices = notices

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryNoticesResponse':
        """Initialize a QueryNoticesResponse object from a json dictionary."""
        args = {}
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        if (notices := _dict.get('notices')) is not None:
            args['notices'] = [Notice.from_dict(v) for v in notices]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryNoticesResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'notices') and self.notices is not None:
            notices_list = []
            for v in self.notices:
                if isinstance(v, dict):
                    notices_list.append(v)
                else:
                    notices_list.append(v.to_dict())
            _dict['notices'] = notices_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryNoticesResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryNoticesResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryNoticesResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryPairAggregationResult:
    """
    Result for the `pair` aggregation.

    :param List[dict] aggregations: (optional) Array of subaggregations of type
          `term`, `group_by`, `histogram`, or `timeslice`. Each element of the matrix that
          is returned contains a **relevancy** value that is calculated from the
          combination of each value from the first and second aggregations.
    """

    def __init__(
        self,
        *,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryPairAggregationResult object.

        :param List[dict] aggregations: (optional) Array of subaggregations of type
               `term`, `group_by`, `histogram`, or `timeslice`. Each element of the matrix
               that is returned contains a **relevancy** value that is calculated from the
               combination of each value from the first and second aggregations.
        """
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryPairAggregationResult':
        """Initialize a QueryPairAggregationResult object from a json dictionary."""
        args = {}
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryPairAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryPairAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryPairAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryPairAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryResponse:
    """
    A response that contains the documents and aggregations for the query.

    :param int matching_results: (optional) The number of matching results for the
          query. Results that match due to a curation only are not counted in the total.
    :param List[QueryResult] results: (optional) Array of document results for the
          query.
    :param List[QueryAggregation] aggregations: (optional) Array of aggregations for
          the query.
    :param RetrievalDetails retrieval_details: (optional) An object contain
          retrieval type information.
    :param str suggested_query: (optional) Suggested correction to the submitted
          **natural_language_query** value.
    :param List[QuerySuggestedRefinement] suggested_refinements: (optional)
          Deprecated: Array of suggested refinements. **Note**: The
          `suggested_refinements` parameter that identified dynamic facets from the data
          is deprecated.
    :param List[QueryTableResult] table_results: (optional) Array of table results.
    :param List[QueryResponsePassage] passages: (optional) Passages that best match
          the query from across all of the collections in the project. Returned if
          **passages.per_document** is `false`.
    """

    def __init__(
        self,
        *,
        matching_results: Optional[int] = None,
        results: Optional[List['QueryResult']] = None,
        aggregations: Optional[List['QueryAggregation']] = None,
        retrieval_details: Optional['RetrievalDetails'] = None,
        suggested_query: Optional[str] = None,
        suggested_refinements: Optional[
            List['QuerySuggestedRefinement']] = None,
        table_results: Optional[List['QueryTableResult']] = None,
        passages: Optional[List['QueryResponsePassage']] = None,
    ) -> None:
        """
        Initialize a QueryResponse object.

        :param int matching_results: (optional) The number of matching results for
               the query. Results that match due to a curation only are not counted in the
               total.
        :param List[QueryResult] results: (optional) Array of document results for
               the query.
        :param List[QueryAggregation] aggregations: (optional) Array of
               aggregations for the query.
        :param RetrievalDetails retrieval_details: (optional) An object contain
               retrieval type information.
        :param str suggested_query: (optional) Suggested correction to the
               submitted **natural_language_query** value.
        :param List[QuerySuggestedRefinement] suggested_refinements: (optional)
               Deprecated: Array of suggested refinements. **Note**: The
               `suggested_refinements` parameter that identified dynamic facets from the
               data is deprecated.
        :param List[QueryTableResult] table_results: (optional) Array of table
               results.
        :param List[QueryResponsePassage] passages: (optional) Passages that best
               match the query from across all of the collections in the project. Returned
               if **passages.per_document** is `false`.
        """
        self.matching_results = matching_results
        self.results = results
        self.aggregations = aggregations
        self.retrieval_details = retrieval_details
        self.suggested_query = suggested_query
        self.suggested_refinements = suggested_refinements
        self.table_results = table_results
        self.passages = passages

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryResponse':
        """Initialize a QueryResponse object from a json dictionary."""
        args = {}
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        if (results := _dict.get('results')) is not None:
            args['results'] = [QueryResult.from_dict(v) for v in results]
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = [
                QueryAggregation.from_dict(v) for v in aggregations
            ]
        if (retrieval_details := _dict.get('retrieval_details')) is not None:
            args['retrieval_details'] = RetrievalDetails.from_dict(
                retrieval_details)
        if (suggested_query := _dict.get('suggested_query')) is not None:
            args['suggested_query'] = suggested_query
        if (suggested_refinements :=
                _dict.get('suggested_refinements')) is not None:
            args['suggested_refinements'] = [
                QuerySuggestedRefinement.from_dict(v)
                for v in suggested_refinements
            ]
        if (table_results := _dict.get('table_results')) is not None:
            args['table_results'] = [
                QueryTableResult.from_dict(v) for v in table_results
            ]
        if (passages := _dict.get('passages')) is not None:
            args['passages'] = [
                QueryResponsePassage.from_dict(v) for v in passages
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            aggregations_list = []
            for v in self.aggregations:
                if isinstance(v, dict):
                    aggregations_list.append(v)
                else:
                    aggregations_list.append(v.to_dict())
            _dict['aggregations'] = aggregations_list
        if hasattr(self,
                   'retrieval_details') and self.retrieval_details is not None:
            if isinstance(self.retrieval_details, dict):
                _dict['retrieval_details'] = self.retrieval_details
            else:
                _dict['retrieval_details'] = self.retrieval_details.to_dict()
        if hasattr(self,
                   'suggested_query') and self.suggested_query is not None:
            _dict['suggested_query'] = self.suggested_query
        if hasattr(self, 'suggested_refinements'
                  ) and self.suggested_refinements is not None:
            suggested_refinements_list = []
            for v in self.suggested_refinements:
                if isinstance(v, dict):
                    suggested_refinements_list.append(v)
                else:
                    suggested_refinements_list.append(v.to_dict())
            _dict['suggested_refinements'] = suggested_refinements_list
        if hasattr(self, 'table_results') and self.table_results is not None:
            table_results_list = []
            for v in self.table_results:
                if isinstance(v, dict):
                    table_results_list.append(v)
                else:
                    table_results_list.append(v.to_dict())
            _dict['table_results'] = table_results_list
        if hasattr(self, 'passages') and self.passages is not None:
            passages_list = []
            for v in self.passages:
                if isinstance(v, dict):
                    passages_list.append(v)
                else:
                    passages_list.append(v.to_dict())
            _dict['passages'] = passages_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryResponsePassage:
    """
    A passage query response.

    :param str passage_text: (optional) The content of the extracted passage.
    :param float passage_score: (optional) The confidence score of the passage's
          analysis. A higher score indicates greater confidence. The score is used to rank
          the passages from all documents and is returned only if
          **passages.per_document** is `false`.
    :param str document_id: (optional) The unique identifier of the ingested
          document.
    :param str collection_id: (optional) The unique identifier of the collection.
    :param int start_offset: (optional) The position of the first character of the
          extracted passage in the originating field.
    :param int end_offset: (optional) The position after the last character of the
          extracted passage in the originating field.
    :param str field: (optional) The label of the field from which the passage has
          been extracted.
    :param List[ResultPassageAnswer] answers: (optional) An array of extracted
          answers to the specified query. Returned for natural language queries when
          **passages.per_document** is `false`.
    """

    def __init__(
        self,
        *,
        passage_text: Optional[str] = None,
        passage_score: Optional[float] = None,
        document_id: Optional[str] = None,
        collection_id: Optional[str] = None,
        start_offset: Optional[int] = None,
        end_offset: Optional[int] = None,
        field: Optional[str] = None,
        answers: Optional[List['ResultPassageAnswer']] = None,
    ) -> None:
        """
        Initialize a QueryResponsePassage object.

        :param str passage_text: (optional) The content of the extracted passage.
        :param float passage_score: (optional) The confidence score of the
               passage's analysis. A higher score indicates greater confidence. The score
               is used to rank the passages from all documents and is returned only if
               **passages.per_document** is `false`.
        :param str document_id: (optional) The unique identifier of the ingested
               document.
        :param str collection_id: (optional) The unique identifier of the
               collection.
        :param int start_offset: (optional) The position of the first character of
               the extracted passage in the originating field.
        :param int end_offset: (optional) The position after the last character of
               the extracted passage in the originating field.
        :param str field: (optional) The label of the field from which the passage
               has been extracted.
        :param List[ResultPassageAnswer] answers: (optional) An array of extracted
               answers to the specified query. Returned for natural language queries when
               **passages.per_document** is `false`.
        """
        self.passage_text = passage_text
        self.passage_score = passage_score
        self.document_id = document_id
        self.collection_id = collection_id
        self.start_offset = start_offset
        self.end_offset = end_offset
        self.field = field
        self.answers = answers

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryResponsePassage':
        """Initialize a QueryResponsePassage object from a json dictionary."""
        args = {}
        if (passage_text := _dict.get('passage_text')) is not None:
            args['passage_text'] = passage_text
        if (passage_score := _dict.get('passage_score')) is not None:
            args['passage_score'] = passage_score
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        if (start_offset := _dict.get('start_offset')) is not None:
            args['start_offset'] = start_offset
        if (end_offset := _dict.get('end_offset')) is not None:
            args['end_offset'] = end_offset
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        if (answers := _dict.get('answers')) is not None:
            args['answers'] = [
                ResultPassageAnswer.from_dict(v) for v in answers
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryResponsePassage object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'passage_text') and self.passage_text is not None:
            _dict['passage_text'] = self.passage_text
        if hasattr(self, 'passage_score') and self.passage_score is not None:
            _dict['passage_score'] = self.passage_score
        if hasattr(self, 'document_id') and self.document_id is not None:
            _dict['document_id'] = self.document_id
        if hasattr(self, 'collection_id') and self.collection_id is not None:
            _dict['collection_id'] = self.collection_id
        if hasattr(self, 'start_offset') and self.start_offset is not None:
            _dict['start_offset'] = self.start_offset
        if hasattr(self, 'end_offset') and self.end_offset is not None:
            _dict['end_offset'] = self.end_offset
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        if hasattr(self, 'answers') and self.answers is not None:
            answers_list = []
            for v in self.answers:
                if isinstance(v, dict):
                    answers_list.append(v)
                else:
                    answers_list.append(v.to_dict())
            _dict['answers'] = answers_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryResponsePassage object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryResponsePassage') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryResponsePassage') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryResult:
    """
    Result document for the specified query.

    :param str document_id: The unique identifier of the document.
    :param dict metadata: (optional) Metadata of the document.
    :param QueryResultMetadata result_metadata: Metadata of a query result.
    :param List[QueryResultPassage] document_passages: (optional) Passages from the
          document that best matches the query. Returned if **passages.per_document** is
          `true`.

    This type supports additional properties of type object. The remaining key-value
    pairs.
    """

    # The set of defined properties for the class
    _properties = frozenset(
        ['document_id', 'metadata', 'result_metadata', 'document_passages'])

    def __init__(
        self,
        document_id: str,
        result_metadata: 'QueryResultMetadata',
        *,
        metadata: Optional[dict] = None,
        document_passages: Optional[List['QueryResultPassage']] = None,
        **kwargs: Optional[object],
    ) -> None:
        """
        Initialize a QueryResult object.

        :param str document_id: The unique identifier of the document.
        :param QueryResultMetadata result_metadata: Metadata of a query result.
        :param dict metadata: (optional) Metadata of the document.
        :param List[QueryResultPassage] document_passages: (optional) Passages from
               the document that best matches the query. Returned if
               **passages.per_document** is `true`.
        :param object **kwargs: (optional) The remaining key-value pairs.
        """
        self.document_id = document_id
        self.metadata = metadata
        self.result_metadata = result_metadata
        self.document_passages = document_passages
        for k, v in kwargs.items():
            if k not in QueryResult._properties:
                if not isinstance(v, object):
                    raise ValueError(
                        'Value for additional property {} must be of type object'
                        .format(k))
                setattr(self, k, v)
            else:
                raise ValueError(
                    'Property {} cannot be specified as an additional property'.
                    format(k))

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryResult':
        """Initialize a QueryResult object from a json dictionary."""
        args = {}
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        else:
            raise ValueError(
                'Required property \'document_id\' not present in QueryResult JSON'
            )
        if (metadata := _dict.get('metadata')) is not None:
            args['metadata'] = metadata
        if (result_metadata := _dict.get('result_metadata')) is not None:
            args['result_metadata'] = QueryResultMetadata.from_dict(
                result_metadata)
        else:
            raise ValueError(
                'Required property \'result_metadata\' not present in QueryResult JSON'
            )
        if (document_passages := _dict.get('document_passages')) is not None:
            args['document_passages'] = [
                QueryResultPassage.from_dict(v) for v in document_passages
            ]
        for k, v in _dict.items():
            if k not in cls._properties:
                if not isinstance(v, object):
                    raise ValueError(
                        'Value for additional property {} must be of type object'
                        .format(k))
                args[k] = v
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_id') and self.document_id is not None:
            _dict['document_id'] = self.document_id
        if hasattr(self, 'metadata') and self.metadata is not None:
            _dict['metadata'] = self.metadata
        if hasattr(self,
                   'result_metadata') and self.result_metadata is not None:
            if isinstance(self.result_metadata, dict):
                _dict['result_metadata'] = self.result_metadata
            else:
                _dict['result_metadata'] = self.result_metadata.to_dict()
        if hasattr(self,
                   'document_passages') and self.document_passages is not None:
            document_passages_list = []
            for v in self.document_passages:
                if isinstance(v, dict):
                    document_passages_list.append(v)
                else:
                    document_passages_list.append(v.to_dict())
            _dict['document_passages'] = document_passages_list
        for k in [
                _k for _k in vars(self).keys()
                if _k not in QueryResult._properties
        ]:
            _dict[k] = getattr(self, k)
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def get_properties(self) -> Dict:
        """Return the additional properties from this instance of QueryResult in the form of a dict."""
        _dict = {}
        for k in [
                _k for _k in vars(self).keys()
                if _k not in QueryResult._properties
        ]:
            _dict[k] = getattr(self, k)
        return _dict

    def set_properties(self, _dict: dict):
        """Set a dictionary of additional properties in this instance of QueryResult"""
        for k in [
                _k for _k in vars(self).keys()
                if _k not in QueryResult._properties
        ]:
            delattr(self, k)
        for k, v in _dict.items():
            if k not in QueryResult._properties:
                if not isinstance(v, object):
                    raise ValueError(
                        'Value for additional property {} must be of type object'
                        .format(k))
                setattr(self, k, v)
            else:
                raise ValueError(
                    'Property {} cannot be specified as an additional property'.
                    format(k))

    def __str__(self) -> str:
        """Return a `str` version of this QueryResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryResultMetadata:
    """
    Metadata of a query result.

    :param str document_retrieval_source: (optional) The document retrieval source
          that produced this search result.
    :param str collection_id: The collection id associated with this training data
          set.
    :param float confidence: (optional) The confidence score for the given result.
          Calculated based on how relevant the result is estimated to be. The score can
          range from `0.0` to `1.0`. The higher the number, the more relevant the
          document. The `confidence` value for a result was calculated using the model
          specified in the `document_retrieval_strategy` field of the result set. This
          field is returned only if the **natural_language_query** parameter is specified
          in the query.
    """

    def __init__(
        self,
        collection_id: str,
        *,
        document_retrieval_source: Optional[str] = None,
        confidence: Optional[float] = None,
    ) -> None:
        """
        Initialize a QueryResultMetadata object.

        :param str collection_id: The collection id associated with this training
               data set.
        :param str document_retrieval_source: (optional) The document retrieval
               source that produced this search result.
        :param float confidence: (optional) The confidence score for the given
               result. Calculated based on how relevant the result is estimated to be. The
               score can range from `0.0` to `1.0`. The higher the number, the more
               relevant the document. The `confidence` value for a result was calculated
               using the model specified in the `document_retrieval_strategy` field of the
               result set. This field is returned only if the **natural_language_query**
               parameter is specified in the query.
        """
        self.document_retrieval_source = document_retrieval_source
        self.collection_id = collection_id
        self.confidence = confidence

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryResultMetadata':
        """Initialize a QueryResultMetadata object from a json dictionary."""
        args = {}
        if (document_retrieval_source :=
                _dict.get('document_retrieval_source')) is not None:
            args['document_retrieval_source'] = document_retrieval_source
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        else:
            raise ValueError(
                'Required property \'collection_id\' not present in QueryResultMetadata JSON'
            )
        if (confidence := _dict.get('confidence')) is not None:
            args['confidence'] = confidence
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryResultMetadata object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_retrieval_source'
                  ) and self.document_retrieval_source is not None:
            _dict['document_retrieval_source'] = self.document_retrieval_source
        if hasattr(self, 'collection_id') and self.collection_id is not None:
            _dict['collection_id'] = self.collection_id
        if hasattr(self, 'confidence') and self.confidence is not None:
            _dict['confidence'] = self.confidence
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryResultMetadata object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryResultMetadata') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryResultMetadata') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class DocumentRetrievalSourceEnum(str, Enum):
        """
        The document retrieval source that produced this search result.
        """

        SEARCH = 'search'
        CURATION = 'curation'


class QueryResultPassage:
    """
    A passage query result.

    :param str passage_text: (optional) The content of the extracted passage.
    :param int start_offset: (optional) The position of the first character of the
          extracted passage in the originating field.
    :param int end_offset: (optional) The position after the last character of the
          extracted passage in the originating field.
    :param str field: (optional) The label of the field from which the passage has
          been extracted.
    :param List[ResultPassageAnswer] answers: (optional) An arry of extracted
          answers to the specified query. Returned for natural language queries when
          **passages.per_document** is `true`.
    """

    def __init__(
        self,
        *,
        passage_text: Optional[str] = None,
        start_offset: Optional[int] = None,
        end_offset: Optional[int] = None,
        field: Optional[str] = None,
        answers: Optional[List['ResultPassageAnswer']] = None,
    ) -> None:
        """
        Initialize a QueryResultPassage object.

        :param str passage_text: (optional) The content of the extracted passage.
        :param int start_offset: (optional) The position of the first character of
               the extracted passage in the originating field.
        :param int end_offset: (optional) The position after the last character of
               the extracted passage in the originating field.
        :param str field: (optional) The label of the field from which the passage
               has been extracted.
        :param List[ResultPassageAnswer] answers: (optional) An arry of extracted
               answers to the specified query. Returned for natural language queries when
               **passages.per_document** is `true`.
        """
        self.passage_text = passage_text
        self.start_offset = start_offset
        self.end_offset = end_offset
        self.field = field
        self.answers = answers

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryResultPassage':
        """Initialize a QueryResultPassage object from a json dictionary."""
        args = {}
        if (passage_text := _dict.get('passage_text')) is not None:
            args['passage_text'] = passage_text
        if (start_offset := _dict.get('start_offset')) is not None:
            args['start_offset'] = start_offset
        if (end_offset := _dict.get('end_offset')) is not None:
            args['end_offset'] = end_offset
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        if (answers := _dict.get('answers')) is not None:
            args['answers'] = [
                ResultPassageAnswer.from_dict(v) for v in answers
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryResultPassage object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'passage_text') and self.passage_text is not None:
            _dict['passage_text'] = self.passage_text
        if hasattr(self, 'start_offset') and self.start_offset is not None:
            _dict['start_offset'] = self.start_offset
        if hasattr(self, 'end_offset') and self.end_offset is not None:
            _dict['end_offset'] = self.end_offset
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        if hasattr(self, 'answers') and self.answers is not None:
            answers_list = []
            for v in self.answers:
                if isinstance(v, dict):
                    answers_list.append(v)
                else:
                    answers_list.append(v.to_dict())
            _dict['answers'] = answers_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryResultPassage object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryResultPassage') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryResultPassage') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QuerySuggestedRefinement:
    """
    A suggested additional query term or terms user to filter results. **Note**: The
    `suggested_refinements` parameter is deprecated.

    :param str text: (optional) The text used to filter.
    """

    def __init__(
        self,
        *,
        text: Optional[str] = None,
    ) -> None:
        """
        Initialize a QuerySuggestedRefinement object.

        :param str text: (optional) The text used to filter.
        """
        self.text = text

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QuerySuggestedRefinement':
        """Initialize a QuerySuggestedRefinement object from a json dictionary."""
        args = {}
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QuerySuggestedRefinement object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QuerySuggestedRefinement object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QuerySuggestedRefinement') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QuerySuggestedRefinement') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryTableResult:
    """
    A tables whose content or context match a search query.

    :param str table_id: (optional) The identifier for the retrieved table.
    :param str source_document_id: (optional) The identifier of the document the
          table was retrieved from.
    :param str collection_id: (optional) The identifier of the collection the table
          was retrieved from.
    :param str table_html: (optional) HTML snippet of the table info.
    :param int table_html_offset: (optional) The offset of the table html snippet in
          the original document html.
    :param TableResultTable table: (optional) Full table object retrieved from Table
          Understanding Enrichment.
    """

    def __init__(
        self,
        *,
        table_id: Optional[str] = None,
        source_document_id: Optional[str] = None,
        collection_id: Optional[str] = None,
        table_html: Optional[str] = None,
        table_html_offset: Optional[int] = None,
        table: Optional['TableResultTable'] = None,
    ) -> None:
        """
        Initialize a QueryTableResult object.

        :param str table_id: (optional) The identifier for the retrieved table.
        :param str source_document_id: (optional) The identifier of the document
               the table was retrieved from.
        :param str collection_id: (optional) The identifier of the collection the
               table was retrieved from.
        :param str table_html: (optional) HTML snippet of the table info.
        :param int table_html_offset: (optional) The offset of the table html
               snippet in the original document html.
        :param TableResultTable table: (optional) Full table object retrieved from
               Table Understanding Enrichment.
        """
        self.table_id = table_id
        self.source_document_id = source_document_id
        self.collection_id = collection_id
        self.table_html = table_html
        self.table_html_offset = table_html_offset
        self.table = table

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryTableResult':
        """Initialize a QueryTableResult object from a json dictionary."""
        args = {}
        if (table_id := _dict.get('table_id')) is not None:
            args['table_id'] = table_id
        if (source_document_id := _dict.get('source_document_id')) is not None:
            args['source_document_id'] = source_document_id
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        if (table_html := _dict.get('table_html')) is not None:
            args['table_html'] = table_html
        if (table_html_offset := _dict.get('table_html_offset')) is not None:
            args['table_html_offset'] = table_html_offset
        if (table := _dict.get('table')) is not None:
            args['table'] = TableResultTable.from_dict(table)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryTableResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'table_id') and self.table_id is not None:
            _dict['table_id'] = self.table_id
        if hasattr(
                self,
                'source_document_id') and self.source_document_id is not None:
            _dict['source_document_id'] = self.source_document_id
        if hasattr(self, 'collection_id') and self.collection_id is not None:
            _dict['collection_id'] = self.collection_id
        if hasattr(self, 'table_html') and self.table_html is not None:
            _dict['table_html'] = self.table_html
        if hasattr(self,
                   'table_html_offset') and self.table_html_offset is not None:
            _dict['table_html_offset'] = self.table_html_offset
        if hasattr(self, 'table') and self.table is not None:
            if isinstance(self.table, dict):
                _dict['table'] = self.table
            else:
                _dict['table'] = self.table.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryTableResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryTableResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryTableResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryTermAggregationResult:
    """
    Top value result for the `term` aggregation.

    :param str key: Value of the field with a nonzero frequency in the document set.
    :param int matching_results: Number of documents that contain the 'key'.
    :param float relevancy: (optional) The relevancy score for this result. Returned
          only if `relevancy:true` is specified in the request.
    :param int total_matching_documents: (optional) Number of documents in the
          collection that contain the term in the specified field. Returned only when
          `relevancy:true` is specified in the request.
    :param float estimated_matching_results: (optional) Number of documents that are
          estimated to match the query and also meet the condition. Returned only when
          `relevancy:true` is specified in the request.
    :param List[dict] aggregations: (optional) An array of subaggregations. Returned
          only when this aggregation is combined with other aggregations in the request or
          is returned as a subaggregation.
    """

    def __init__(
        self,
        key: str,
        matching_results: int,
        *,
        relevancy: Optional[float] = None,
        total_matching_documents: Optional[int] = None,
        estimated_matching_results: Optional[float] = None,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryTermAggregationResult object.

        :param str key: Value of the field with a nonzero frequency in the document
               set.
        :param int matching_results: Number of documents that contain the 'key'.
        :param float relevancy: (optional) The relevancy score for this result.
               Returned only if `relevancy:true` is specified in the request.
        :param int total_matching_documents: (optional) Number of documents in the
               collection that contain the term in the specified field. Returned only when
               `relevancy:true` is specified in the request.
        :param float estimated_matching_results: (optional) Number of documents
               that are estimated to match the query and also meet the condition. Returned
               only when `relevancy:true` is specified in the request.
        :param List[dict] aggregations: (optional) An array of subaggregations.
               Returned only when this aggregation is combined with other aggregations in
               the request or is returned as a subaggregation.
        """
        self.key = key
        self.matching_results = matching_results
        self.relevancy = relevancy
        self.total_matching_documents = total_matching_documents
        self.estimated_matching_results = estimated_matching_results
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryTermAggregationResult':
        """Initialize a QueryTermAggregationResult object from a json dictionary."""
        args = {}
        if (key := _dict.get('key')) is not None:
            args['key'] = key
        else:
            raise ValueError(
                'Required property \'key\' not present in QueryTermAggregationResult JSON'
            )
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryTermAggregationResult JSON'
            )
        if (relevancy := _dict.get('relevancy')) is not None:
            args['relevancy'] = relevancy
        if (total_matching_documents :=
                _dict.get('total_matching_documents')) is not None:
            args['total_matching_documents'] = total_matching_documents
        if (estimated_matching_results :=
                _dict.get('estimated_matching_results')) is not None:
            args['estimated_matching_results'] = estimated_matching_results
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryTermAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'key') and self.key is not None:
            _dict['key'] = self.key
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'relevancy') and self.relevancy is not None:
            _dict['relevancy'] = self.relevancy
        if hasattr(self, 'total_matching_documents'
                  ) and self.total_matching_documents is not None:
            _dict['total_matching_documents'] = self.total_matching_documents
        if hasattr(self, 'estimated_matching_results'
                  ) and self.estimated_matching_results is not None:
            _dict[
                'estimated_matching_results'] = self.estimated_matching_results
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryTermAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryTermAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryTermAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryTimesliceAggregationResult:
    """
    A timeslice interval segment.

    :param str key_as_string: String date value of the upper bound for the timeslice
          interval in ISO-8601 format.
    :param int key: Numeric date value of the upper bound for the timeslice interval
          in UNIX milliseconds since epoch.
    :param int matching_results: Number of documents with the specified key as the
          upper bound.
    :param List[dict] aggregations: (optional) An array of subaggregations. Returned
          only when this aggregation is returned as a subaggregation.
    """

    def __init__(
        self,
        key_as_string: str,
        key: int,
        matching_results: int,
        *,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryTimesliceAggregationResult object.

        :param str key_as_string: String date value of the upper bound for the
               timeslice interval in ISO-8601 format.
        :param int key: Numeric date value of the upper bound for the timeslice
               interval in UNIX milliseconds since epoch.
        :param int matching_results: Number of documents with the specified key as
               the upper bound.
        :param List[dict] aggregations: (optional) An array of subaggregations.
               Returned only when this aggregation is returned as a subaggregation.
        """
        self.key_as_string = key_as_string
        self.key = key
        self.matching_results = matching_results
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryTimesliceAggregationResult':
        """Initialize a QueryTimesliceAggregationResult object from a json dictionary."""
        args = {}
        if (key_as_string := _dict.get('key_as_string')) is not None:
            args['key_as_string'] = key_as_string
        else:
            raise ValueError(
                'Required property \'key_as_string\' not present in QueryTimesliceAggregationResult JSON'
            )
        if (key := _dict.get('key')) is not None:
            args['key'] = key
        else:
            raise ValueError(
                'Required property \'key\' not present in QueryTimesliceAggregationResult JSON'
            )
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryTimesliceAggregationResult JSON'
            )
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryTimesliceAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'key_as_string') and self.key_as_string is not None:
            _dict['key_as_string'] = self.key_as_string
        if hasattr(self, 'key') and self.key is not None:
            _dict['key'] = self.key
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryTimesliceAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryTimesliceAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryTimesliceAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryTopHitsAggregationResult:
    """
    A query response that contains the matching documents for the preceding aggregations.

    :param int matching_results: Number of matching results.
    :param List[dict] hits: (optional) An array of the document results in an
          ordered list.
    """

    def __init__(
        self,
        matching_results: int,
        *,
        hits: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryTopHitsAggregationResult object.

        :param int matching_results: Number of matching results.
        :param List[dict] hits: (optional) An array of the document results in an
               ordered list.
        """
        self.matching_results = matching_results
        self.hits = hits

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryTopHitsAggregationResult':
        """Initialize a QueryTopHitsAggregationResult object from a json dictionary."""
        args = {}
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryTopHitsAggregationResult JSON'
            )
        if (hits := _dict.get('hits')) is not None:
            args['hits'] = hits
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryTopHitsAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'hits') and self.hits is not None:
            _dict['hits'] = self.hits
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryTopHitsAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryTopHitsAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryTopHitsAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryTopicAggregationResult:
    """
    Result for the `topic` aggregation.

    :param List[dict] aggregations: (optional) Array of subaggregations  of type
          `term` or `group_by` and `timeslice`. Each element of the matrix that is
          returned contains a **topic_indicator** that is calculated from the combination
          of each aggregation value and segment of time.
    """

    def __init__(
        self,
        *,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryTopicAggregationResult object.

        :param List[dict] aggregations: (optional) Array of subaggregations  of
               type `term` or `group_by` and `timeslice`. Each element of the matrix that
               is returned contains a **topic_indicator** that is calculated from the
               combination of each aggregation value and segment of time.
        """
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryTopicAggregationResult':
        """Initialize a QueryTopicAggregationResult object from a json dictionary."""
        args = {}
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryTopicAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryTopicAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryTopicAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryTopicAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryTrendAggregationResult:
    """
    Result for the `trend` aggregation.

    :param List[dict] aggregations: (optional) Array of subaggregations of type
          `term` or `group_by` and `timeslice`. Each element of the matrix that is
          returned contains a **trend_indicator** that is calculated from the combination
          of each aggregation value and segment of time.
    """

    def __init__(
        self,
        *,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryTrendAggregationResult object.

        :param List[dict] aggregations: (optional) Array of subaggregations of type
               `term` or `group_by` and `timeslice`. Each element of the matrix that is
               returned contains a **trend_indicator** that is calculated from the
               combination of each aggregation value and segment of time.
        """
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryTrendAggregationResult':
        """Initialize a QueryTrendAggregationResult object from a json dictionary."""
        args = {}
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryTrendAggregationResult object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryTrendAggregationResult object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryTrendAggregationResult') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryTrendAggregationResult') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class ResultPassageAnswer:
    """
    Object that contains a potential answer to the specified query.

    :param str answer_text: (optional) Answer text for the specified query as
          identified by Discovery.
    :param int start_offset: (optional) The position of the first character of the
          extracted answer in the originating field.
    :param int end_offset: (optional) The position after the last character of the
          extracted answer in the originating field.
    :param float confidence: (optional) An estimate of the probability that the
          answer is relevant.
    """

    def __init__(
        self,
        *,
        answer_text: Optional[str] = None,
        start_offset: Optional[int] = None,
        end_offset: Optional[int] = None,
        confidence: Optional[float] = None,
    ) -> None:
        """
        Initialize a ResultPassageAnswer object.

        :param str answer_text: (optional) Answer text for the specified query as
               identified by Discovery.
        :param int start_offset: (optional) The position of the first character of
               the extracted answer in the originating field.
        :param int end_offset: (optional) The position after the last character of
               the extracted answer in the originating field.
        :param float confidence: (optional) An estimate of the probability that the
               answer is relevant.
        """
        self.answer_text = answer_text
        self.start_offset = start_offset
        self.end_offset = end_offset
        self.confidence = confidence

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'ResultPassageAnswer':
        """Initialize a ResultPassageAnswer object from a json dictionary."""
        args = {}
        if (answer_text := _dict.get('answer_text')) is not None:
            args['answer_text'] = answer_text
        if (start_offset := _dict.get('start_offset')) is not None:
            args['start_offset'] = start_offset
        if (end_offset := _dict.get('end_offset')) is not None:
            args['end_offset'] = end_offset
        if (confidence := _dict.get('confidence')) is not None:
            args['confidence'] = confidence
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a ResultPassageAnswer object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'answer_text') and self.answer_text is not None:
            _dict['answer_text'] = self.answer_text
        if hasattr(self, 'start_offset') and self.start_offset is not None:
            _dict['start_offset'] = self.start_offset
        if hasattr(self, 'end_offset') and self.end_offset is not None:
            _dict['end_offset'] = self.end_offset
        if hasattr(self, 'confidence') and self.confidence is not None:
            _dict['confidence'] = self.confidence
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this ResultPassageAnswer object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'ResultPassageAnswer') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'ResultPassageAnswer') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class RetrievalDetails:
    """
    An object contain retrieval type information.

    :param str document_retrieval_strategy: (optional) Identifies the document
          retrieval strategy used for this query. `relevancy_training` indicates that the
          results were returned using a relevancy trained model.
          **Note**: In the event of trained collections being queried, but the trained
          model is not used to return results, the **document_retrieval_strategy** is
          listed as `untrained`.
    """

    def __init__(
        self,
        *,
        document_retrieval_strategy: Optional[str] = None,
    ) -> None:
        """
        Initialize a RetrievalDetails object.

        :param str document_retrieval_strategy: (optional) Identifies the document
               retrieval strategy used for this query. `relevancy_training` indicates that
               the results were returned using a relevancy trained model.
               **Note**: In the event of trained collections being queried, but the
               trained model is not used to return results, the
               **document_retrieval_strategy** is listed as `untrained`.
        """
        self.document_retrieval_strategy = document_retrieval_strategy

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'RetrievalDetails':
        """Initialize a RetrievalDetails object from a json dictionary."""
        args = {}
        if (document_retrieval_strategy :=
                _dict.get('document_retrieval_strategy')) is not None:
            args['document_retrieval_strategy'] = document_retrieval_strategy
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a RetrievalDetails object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_retrieval_strategy'
                  ) and self.document_retrieval_strategy is not None:
            _dict[
                'document_retrieval_strategy'] = self.document_retrieval_strategy
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this RetrievalDetails object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'RetrievalDetails') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'RetrievalDetails') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other

    class DocumentRetrievalStrategyEnum(str, Enum):
        """
        Identifies the document retrieval strategy used for this query.
        `relevancy_training` indicates that the results were returned using a relevancy
        trained model.
        **Note**: In the event of trained collections being queried, but the trained model
        is not used to return results, the **document_retrieval_strategy** is listed as
        `untrained`.
        """

        UNTRAINED = 'untrained'
        RELEVANCY_TRAINING = 'relevancy_training'


class StopWordList:
    """
    List of words to filter out of text that is submitted in queries.

    :param List[str] stopwords: List of stop words.
    """

    def __init__(
        self,
        stopwords: List[str],
    ) -> None:
        """
        Initialize a StopWordList object.

        :param List[str] stopwords: List of stop words.
        """
        self.stopwords = stopwords

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'StopWordList':
        """Initialize a StopWordList object from a json dictionary."""
        args = {}
        if (stopwords := _dict.get('stopwords')) is not None:
            args['stopwords'] = stopwords
        else:
            raise ValueError(
                'Required property \'stopwords\' not present in StopWordList JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a StopWordList object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'stopwords') and self.stopwords is not None:
            _dict['stopwords'] = self.stopwords
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this StopWordList object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'StopWordList') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'StopWordList') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableBodyCells:
    """
    Cells that are not table header, column header, or row header cells.

    :param str cell_id: (optional) The unique ID of the cell in the current table.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The textual contents of this cell from the input
          document without associated markup content.
    :param int row_index_begin: (optional) The `begin` index of this cell's `row`
          location in the current table.
    :param int row_index_end: (optional) The `end` index of this cell's `row`
          location in the current table.
    :param int column_index_begin: (optional) The `begin` index of this cell's
          `column` location in the current table.
    :param int column_index_end: (optional) The `end` index of this cell's `column`
          location in the current table.
    :param List[str] row_header_ids: (optional) A list of ID values that represent
          the table row headers that are associated with this body cell.
    :param List[str] row_header_texts: (optional) A list of row header values that
          are associated with this body cell.
    :param List[str] row_header_texts_normalized: (optional) A list of normalized
          row header values that are associated with this body cell.
    :param List[str] column_header_ids: (optional) A list of ID values that
          represent the column headers that are associated with this body cell.
    :param List[str] column_header_texts: (optional) A list of column header values
          that are associated with this body cell.
    :param List[str] column_header_texts_normalized: (optional) A list of normalized
          column header values that are associated with this body cell.
    :param List[DocumentAttribute] attributes: (optional) A list of document
          attributes.
    """

    def __init__(
        self,
        *,
        cell_id: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
        row_index_begin: Optional[int] = None,
        row_index_end: Optional[int] = None,
        column_index_begin: Optional[int] = None,
        column_index_end: Optional[int] = None,
        row_header_ids: Optional[List[str]] = None,
        row_header_texts: Optional[List[str]] = None,
        row_header_texts_normalized: Optional[List[str]] = None,
        column_header_ids: Optional[List[str]] = None,
        column_header_texts: Optional[List[str]] = None,
        column_header_texts_normalized: Optional[List[str]] = None,
        attributes: Optional[List['DocumentAttribute']] = None,
    ) -> None:
        """
        Initialize a TableBodyCells object.

        :param str cell_id: (optional) The unique ID of the cell in the current
               table.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The textual contents of this cell from the
               input document without associated markup content.
        :param int row_index_begin: (optional) The `begin` index of this cell's
               `row` location in the current table.
        :param int row_index_end: (optional) The `end` index of this cell's `row`
               location in the current table.
        :param int column_index_begin: (optional) The `begin` index of this cell's
               `column` location in the current table.
        :param int column_index_end: (optional) The `end` index of this cell's
               `column` location in the current table.
        :param List[str] row_header_ids: (optional) A list of ID values that
               represent the table row headers that are associated with this body cell.
        :param List[str] row_header_texts: (optional) A list of row header values
               that are associated with this body cell.
        :param List[str] row_header_texts_normalized: (optional) A list of
               normalized row header values that are associated with this body cell.
        :param List[str] column_header_ids: (optional) A list of ID values that
               represent the column headers that are associated with this body cell.
        :param List[str] column_header_texts: (optional) A list of column header
               values that are associated with this body cell.
        :param List[str] column_header_texts_normalized: (optional) A list of
               normalized column header values that are associated with this body cell.
        :param List[DocumentAttribute] attributes: (optional) A list of document
               attributes.
        """
        self.cell_id = cell_id
        self.location = location
        self.text = text
        self.row_index_begin = row_index_begin
        self.row_index_end = row_index_end
        self.column_index_begin = column_index_begin
        self.column_index_end = column_index_end
        self.row_header_ids = row_header_ids
        self.row_header_texts = row_header_texts
        self.row_header_texts_normalized = row_header_texts_normalized
        self.column_header_ids = column_header_ids
        self.column_header_texts = column_header_texts
        self.column_header_texts_normalized = column_header_texts_normalized
        self.attributes = attributes

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableBodyCells':
        """Initialize a TableBodyCells object from a json dictionary."""
        args = {}
        if (cell_id := _dict.get('cell_id')) is not None:
            args['cell_id'] = cell_id
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (row_index_begin := _dict.get('row_index_begin')) is not None:
            args['row_index_begin'] = row_index_begin
        if (row_index_end := _dict.get('row_index_end')) is not None:
            args['row_index_end'] = row_index_end
        if (column_index_begin := _dict.get('column_index_begin')) is not None:
            args['column_index_begin'] = column_index_begin
        if (column_index_end := _dict.get('column_index_end')) is not None:
            args['column_index_end'] = column_index_end
        if (row_header_ids := _dict.get('row_header_ids')) is not None:
            args['row_header_ids'] = row_header_ids
        if (row_header_texts := _dict.get('row_header_texts')) is not None:
            args['row_header_texts'] = row_header_texts
        if (row_header_texts_normalized :=
                _dict.get('row_header_texts_normalized')) is not None:
            args['row_header_texts_normalized'] = row_header_texts_normalized
        if (column_header_ids := _dict.get('column_header_ids')) is not None:
            args['column_header_ids'] = column_header_ids
        if (column_header_texts :=
                _dict.get('column_header_texts')) is not None:
            args['column_header_texts'] = column_header_texts
        if (column_header_texts_normalized :=
                _dict.get('column_header_texts_normalized')) is not None:
            args[
                'column_header_texts_normalized'] = column_header_texts_normalized
        if (attributes := _dict.get('attributes')) is not None:
            args['attributes'] = [
                DocumentAttribute.from_dict(v) for v in attributes
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableBodyCells object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'cell_id') and self.cell_id is not None:
            _dict['cell_id'] = self.cell_id
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self,
                   'row_index_begin') and self.row_index_begin is not None:
            _dict['row_index_begin'] = self.row_index_begin
        if hasattr(self, 'row_index_end') and self.row_index_end is not None:
            _dict['row_index_end'] = self.row_index_end
        if hasattr(
                self,
                'column_index_begin') and self.column_index_begin is not None:
            _dict['column_index_begin'] = self.column_index_begin
        if hasattr(self,
                   'column_index_end') and self.column_index_end is not None:
            _dict['column_index_end'] = self.column_index_end
        if hasattr(self, 'row_header_ids') and self.row_header_ids is not None:
            _dict['row_header_ids'] = self.row_header_ids
        if hasattr(self,
                   'row_header_texts') and self.row_header_texts is not None:
            _dict['row_header_texts'] = self.row_header_texts
        if hasattr(self, 'row_header_texts_normalized'
                  ) and self.row_header_texts_normalized is not None:
            _dict[
                'row_header_texts_normalized'] = self.row_header_texts_normalized
        if hasattr(self,
                   'column_header_ids') and self.column_header_ids is not None:
            _dict['column_header_ids'] = self.column_header_ids
        if hasattr(
                self,
                'column_header_texts') and self.column_header_texts is not None:
            _dict['column_header_texts'] = self.column_header_texts
        if hasattr(self, 'column_header_texts_normalized'
                  ) and self.column_header_texts_normalized is not None:
            _dict[
                'column_header_texts_normalized'] = self.column_header_texts_normalized
        if hasattr(self, 'attributes') and self.attributes is not None:
            attributes_list = []
            for v in self.attributes:
                if isinstance(v, dict):
                    attributes_list.append(v)
                else:
                    attributes_list.append(v.to_dict())
            _dict['attributes'] = attributes_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableBodyCells object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableBodyCells') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableBodyCells') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableCellKey:
    """
    A key in a key-value pair.

    :param str cell_id: (optional) The unique ID of the key in the table.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The text content of the table cell without HTML
          markup.
    """

    def __init__(
        self,
        *,
        cell_id: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
    ) -> None:
        """
        Initialize a TableCellKey object.

        :param str cell_id: (optional) The unique ID of the key in the table.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The text content of the table cell without HTML
               markup.
        """
        self.cell_id = cell_id
        self.location = location
        self.text = text

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableCellKey':
        """Initialize a TableCellKey object from a json dictionary."""
        args = {}
        if (cell_id := _dict.get('cell_id')) is not None:
            args['cell_id'] = cell_id
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableCellKey object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'cell_id') and self.cell_id is not None:
            _dict['cell_id'] = self.cell_id
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableCellKey object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableCellKey') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableCellKey') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableCellValues:
    """
    A value in a key-value pair.

    :param str cell_id: (optional) The unique ID of the value in the table.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The text content of the table cell without HTML
          markup.
    """

    def __init__(
        self,
        *,
        cell_id: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
    ) -> None:
        """
        Initialize a TableCellValues object.

        :param str cell_id: (optional) The unique ID of the value in the table.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The text content of the table cell without HTML
               markup.
        """
        self.cell_id = cell_id
        self.location = location
        self.text = text

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableCellValues':
        """Initialize a TableCellValues object from a json dictionary."""
        args = {}
        if (cell_id := _dict.get('cell_id')) is not None:
            args['cell_id'] = cell_id
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableCellValues object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'cell_id') and self.cell_id is not None:
            _dict['cell_id'] = self.cell_id
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableCellValues object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableCellValues') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableCellValues') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableColumnHeaders:
    """
    Column-level cells, each applicable as a header to other cells in the same column as
    itself, of the current table.

    :param str cell_id: (optional) The unique ID of the cell in the current table.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The textual contents of this cell from the input
          document without associated markup content.
    :param str text_normalized: (optional) Normalized column header text.
    :param int row_index_begin: (optional) The `begin` index of this cell's `row`
          location in the current table.
    :param int row_index_end: (optional) The `end` index of this cell's `row`
          location in the current table.
    :param int column_index_begin: (optional) The `begin` index of this cell's
          `column` location in the current table.
    :param int column_index_end: (optional) The `end` index of this cell's `column`
          location in the current table.
    """

    def __init__(
        self,
        *,
        cell_id: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
        text_normalized: Optional[str] = None,
        row_index_begin: Optional[int] = None,
        row_index_end: Optional[int] = None,
        column_index_begin: Optional[int] = None,
        column_index_end: Optional[int] = None,
    ) -> None:
        """
        Initialize a TableColumnHeaders object.

        :param str cell_id: (optional) The unique ID of the cell in the current
               table.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The textual contents of this cell from the
               input document without associated markup content.
        :param str text_normalized: (optional) Normalized column header text.
        :param int row_index_begin: (optional) The `begin` index of this cell's
               `row` location in the current table.
        :param int row_index_end: (optional) The `end` index of this cell's `row`
               location in the current table.
        :param int column_index_begin: (optional) The `begin` index of this cell's
               `column` location in the current table.
        :param int column_index_end: (optional) The `end` index of this cell's
               `column` location in the current table.
        """
        self.cell_id = cell_id
        self.location = location
        self.text = text
        self.text_normalized = text_normalized
        self.row_index_begin = row_index_begin
        self.row_index_end = row_index_end
        self.column_index_begin = column_index_begin
        self.column_index_end = column_index_end

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableColumnHeaders':
        """Initialize a TableColumnHeaders object from a json dictionary."""
        args = {}
        if (cell_id := _dict.get('cell_id')) is not None:
            args['cell_id'] = cell_id
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (text_normalized := _dict.get('text_normalized')) is not None:
            args['text_normalized'] = text_normalized
        if (row_index_begin := _dict.get('row_index_begin')) is not None:
            args['row_index_begin'] = row_index_begin
        if (row_index_end := _dict.get('row_index_end')) is not None:
            args['row_index_end'] = row_index_end
        if (column_index_begin := _dict.get('column_index_begin')) is not None:
            args['column_index_begin'] = column_index_begin
        if (column_index_end := _dict.get('column_index_end')) is not None:
            args['column_index_end'] = column_index_end
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableColumnHeaders object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'cell_id') and self.cell_id is not None:
            _dict['cell_id'] = self.cell_id
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self,
                   'text_normalized') and self.text_normalized is not None:
            _dict['text_normalized'] = self.text_normalized
        if hasattr(self,
                   'row_index_begin') and self.row_index_begin is not None:
            _dict['row_index_begin'] = self.row_index_begin
        if hasattr(self, 'row_index_end') and self.row_index_end is not None:
            _dict['row_index_end'] = self.row_index_end
        if hasattr(
                self,
                'column_index_begin') and self.column_index_begin is not None:
            _dict['column_index_begin'] = self.column_index_begin
        if hasattr(self,
                   'column_index_end') and self.column_index_end is not None:
            _dict['column_index_end'] = self.column_index_end
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableColumnHeaders object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableColumnHeaders') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableColumnHeaders') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableElementLocation:
    """
    The numeric location of the identified element in the document, represented with two
    integers labeled `begin` and `end`.

    :param int begin: The element's `begin` index.
    :param int end: The element's `end` index.
    """

    def __init__(
        self,
        begin: int,
        end: int,
    ) -> None:
        """
        Initialize a TableElementLocation object.

        :param int begin: The element's `begin` index.
        :param int end: The element's `end` index.
        """
        self.begin = begin
        self.end = end

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableElementLocation':
        """Initialize a TableElementLocation object from a json dictionary."""
        args = {}
        if (begin := _dict.get('begin')) is not None:
            args['begin'] = begin
        else:
            raise ValueError(
                'Required property \'begin\' not present in TableElementLocation JSON'
            )
        if (end := _dict.get('end')) is not None:
            args['end'] = end
        else:
            raise ValueError(
                'Required property \'end\' not present in TableElementLocation JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableElementLocation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'begin') and self.begin is not None:
            _dict['begin'] = self.begin
        if hasattr(self, 'end') and self.end is not None:
            _dict['end'] = self.end
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableElementLocation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableElementLocation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableElementLocation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableHeaders:
    """
    The contents of the current table's header.

    :param str cell_id: (optional) The unique ID of the cell in the current table.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The textual contents of the cell from the input
          document without associated markup content.
    :param int row_index_begin: (optional) The `begin` index of this cell's `row`
          location in the current table.
    :param int row_index_end: (optional) The `end` index of this cell's `row`
          location in the current table.
    :param int column_index_begin: (optional) The `begin` index of this cell's
          `column` location in the current table.
    :param int column_index_end: (optional) The `end` index of this cell's `column`
          location in the current table.
    """

    def __init__(
        self,
        *,
        cell_id: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
        row_index_begin: Optional[int] = None,
        row_index_end: Optional[int] = None,
        column_index_begin: Optional[int] = None,
        column_index_end: Optional[int] = None,
    ) -> None:
        """
        Initialize a TableHeaders object.

        :param str cell_id: (optional) The unique ID of the cell in the current
               table.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The textual contents of the cell from the input
               document without associated markup content.
        :param int row_index_begin: (optional) The `begin` index of this cell's
               `row` location in the current table.
        :param int row_index_end: (optional) The `end` index of this cell's `row`
               location in the current table.
        :param int column_index_begin: (optional) The `begin` index of this cell's
               `column` location in the current table.
        :param int column_index_end: (optional) The `end` index of this cell's
               `column` location in the current table.
        """
        self.cell_id = cell_id
        self.location = location
        self.text = text
        self.row_index_begin = row_index_begin
        self.row_index_end = row_index_end
        self.column_index_begin = column_index_begin
        self.column_index_end = column_index_end

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableHeaders':
        """Initialize a TableHeaders object from a json dictionary."""
        args = {}
        if (cell_id := _dict.get('cell_id')) is not None:
            args['cell_id'] = cell_id
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (row_index_begin := _dict.get('row_index_begin')) is not None:
            args['row_index_begin'] = row_index_begin
        if (row_index_end := _dict.get('row_index_end')) is not None:
            args['row_index_end'] = row_index_end
        if (column_index_begin := _dict.get('column_index_begin')) is not None:
            args['column_index_begin'] = column_index_begin
        if (column_index_end := _dict.get('column_index_end')) is not None:
            args['column_index_end'] = column_index_end
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableHeaders object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'cell_id') and self.cell_id is not None:
            _dict['cell_id'] = self.cell_id
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self,
                   'row_index_begin') and self.row_index_begin is not None:
            _dict['row_index_begin'] = self.row_index_begin
        if hasattr(self, 'row_index_end') and self.row_index_end is not None:
            _dict['row_index_end'] = self.row_index_end
        if hasattr(
                self,
                'column_index_begin') and self.column_index_begin is not None:
            _dict['column_index_begin'] = self.column_index_begin
        if hasattr(self,
                   'column_index_end') and self.column_index_end is not None:
            _dict['column_index_end'] = self.column_index_end
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableHeaders object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableHeaders') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableHeaders') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableKeyValuePairs:
    """
    Key-value pairs detected across cell boundaries.

    :param TableCellKey key: (optional) A key in a key-value pair.
    :param List[TableCellValues] value: (optional) A list of values in a key-value
          pair.
    """

    def __init__(
        self,
        *,
        key: Optional['TableCellKey'] = None,
        value: Optional[List['TableCellValues']] = None,
    ) -> None:
        """
        Initialize a TableKeyValuePairs object.

        :param TableCellKey key: (optional) A key in a key-value pair.
        :param List[TableCellValues] value: (optional) A list of values in a
               key-value pair.
        """
        self.key = key
        self.value = value

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableKeyValuePairs':
        """Initialize a TableKeyValuePairs object from a json dictionary."""
        args = {}
        if (key := _dict.get('key')) is not None:
            args['key'] = TableCellKey.from_dict(key)
        if (value := _dict.get('value')) is not None:
            args['value'] = [TableCellValues.from_dict(v) for v in value]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableKeyValuePairs object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'key') and self.key is not None:
            if isinstance(self.key, dict):
                _dict['key'] = self.key
            else:
                _dict['key'] = self.key.to_dict()
        if hasattr(self, 'value') and self.value is not None:
            value_list = []
            for v in self.value:
                if isinstance(v, dict):
                    value_list.append(v)
                else:
                    value_list.append(v.to_dict())
            _dict['value'] = value_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableKeyValuePairs object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableKeyValuePairs') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableKeyValuePairs') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableResultTable:
    """
    Full table object retrieved from Table Understanding Enrichment.

    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The textual contents of the current table from the
          input document without associated markup content.
    :param TableTextLocation section_title: (optional) Text and associated location
          within a table.
    :param TableTextLocation title: (optional) Text and associated location within a
          table.
    :param List[TableHeaders] table_headers: (optional) An array of table-level
          cells that apply as headers to all the other cells in the current table.
    :param List[TableRowHeaders] row_headers: (optional) An array of row-level
          cells, each applicable as a header to other cells in the same row as itself, of
          the current table.
    :param List[TableColumnHeaders] column_headers: (optional) An array of
          column-level cells, each applicable as a header to other cells in the same
          column as itself, of the current table.
    :param List[TableKeyValuePairs] key_value_pairs: (optional) An array of
          key-value pairs identified in the current table.
    :param List[TableBodyCells] body_cells: (optional) An array of cells that are
          neither table header nor column header nor row header cells, of the current
          table with corresponding row and column header associations.
    :param List[TableTextLocation] contexts: (optional) An array of lists of textual
          entries across the document related to the current table being parsed.
    """

    def __init__(
        self,
        *,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
        section_title: Optional['TableTextLocation'] = None,
        title: Optional['TableTextLocation'] = None,
        table_headers: Optional[List['TableHeaders']] = None,
        row_headers: Optional[List['TableRowHeaders']] = None,
        column_headers: Optional[List['TableColumnHeaders']] = None,
        key_value_pairs: Optional[List['TableKeyValuePairs']] = None,
        body_cells: Optional[List['TableBodyCells']] = None,
        contexts: Optional[List['TableTextLocation']] = None,
    ) -> None:
        """
        Initialize a TableResultTable object.

        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The textual contents of the current table from
               the input document without associated markup content.
        :param TableTextLocation section_title: (optional) Text and associated
               location within a table.
        :param TableTextLocation title: (optional) Text and associated location
               within a table.
        :param List[TableHeaders] table_headers: (optional) An array of table-level
               cells that apply as headers to all the other cells in the current table.
        :param List[TableRowHeaders] row_headers: (optional) An array of row-level
               cells, each applicable as a header to other cells in the same row as
               itself, of the current table.
        :param List[TableColumnHeaders] column_headers: (optional) An array of
               column-level cells, each applicable as a header to other cells in the same
               column as itself, of the current table.
        :param List[TableKeyValuePairs] key_value_pairs: (optional) An array of
               key-value pairs identified in the current table.
        :param List[TableBodyCells] body_cells: (optional) An array of cells that
               are neither table header nor column header nor row header cells, of the
               current table with corresponding row and column header associations.
        :param List[TableTextLocation] contexts: (optional) An array of lists of
               textual entries across the document related to the current table being
               parsed.
        """
        self.location = location
        self.text = text
        self.section_title = section_title
        self.title = title
        self.table_headers = table_headers
        self.row_headers = row_headers
        self.column_headers = column_headers
        self.key_value_pairs = key_value_pairs
        self.body_cells = body_cells
        self.contexts = contexts

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableResultTable':
        """Initialize a TableResultTable object from a json dictionary."""
        args = {}
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (section_title := _dict.get('section_title')) is not None:
            args['section_title'] = TableTextLocation.from_dict(section_title)
        if (title := _dict.get('title')) is not None:
            args['title'] = TableTextLocation.from_dict(title)
        if (table_headers := _dict.get('table_headers')) is not None:
            args['table_headers'] = [
                TableHeaders.from_dict(v) for v in table_headers
            ]
        if (row_headers := _dict.get('row_headers')) is not None:
            args['row_headers'] = [
                TableRowHeaders.from_dict(v) for v in row_headers
            ]
        if (column_headers := _dict.get('column_headers')) is not None:
            args['column_headers'] = [
                TableColumnHeaders.from_dict(v) for v in column_headers
            ]
        if (key_value_pairs := _dict.get('key_value_pairs')) is not None:
            args['key_value_pairs'] = [
                TableKeyValuePairs.from_dict(v) for v in key_value_pairs
            ]
        if (body_cells := _dict.get('body_cells')) is not None:
            args['body_cells'] = [
                TableBodyCells.from_dict(v) for v in body_cells
            ]
        if (contexts := _dict.get('contexts')) is not None:
            args['contexts'] = [
                TableTextLocation.from_dict(v) for v in contexts
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableResultTable object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self, 'section_title') and self.section_title is not None:
            if isinstance(self.section_title, dict):
                _dict['section_title'] = self.section_title
            else:
                _dict['section_title'] = self.section_title.to_dict()
        if hasattr(self, 'title') and self.title is not None:
            if isinstance(self.title, dict):
                _dict['title'] = self.title
            else:
                _dict['title'] = self.title.to_dict()
        if hasattr(self, 'table_headers') and self.table_headers is not None:
            table_headers_list = []
            for v in self.table_headers:
                if isinstance(v, dict):
                    table_headers_list.append(v)
                else:
                    table_headers_list.append(v.to_dict())
            _dict['table_headers'] = table_headers_list
        if hasattr(self, 'row_headers') and self.row_headers is not None:
            row_headers_list = []
            for v in self.row_headers:
                if isinstance(v, dict):
                    row_headers_list.append(v)
                else:
                    row_headers_list.append(v.to_dict())
            _dict['row_headers'] = row_headers_list
        if hasattr(self, 'column_headers') and self.column_headers is not None:
            column_headers_list = []
            for v in self.column_headers:
                if isinstance(v, dict):
                    column_headers_list.append(v)
                else:
                    column_headers_list.append(v.to_dict())
            _dict['column_headers'] = column_headers_list
        if hasattr(self,
                   'key_value_pairs') and self.key_value_pairs is not None:
            key_value_pairs_list = []
            for v in self.key_value_pairs:
                if isinstance(v, dict):
                    key_value_pairs_list.append(v)
                else:
                    key_value_pairs_list.append(v.to_dict())
            _dict['key_value_pairs'] = key_value_pairs_list
        if hasattr(self, 'body_cells') and self.body_cells is not None:
            body_cells_list = []
            for v in self.body_cells:
                if isinstance(v, dict):
                    body_cells_list.append(v)
                else:
                    body_cells_list.append(v.to_dict())
            _dict['body_cells'] = body_cells_list
        if hasattr(self, 'contexts') and self.contexts is not None:
            contexts_list = []
            for v in self.contexts:
                if isinstance(v, dict):
                    contexts_list.append(v)
                else:
                    contexts_list.append(v.to_dict())
            _dict['contexts'] = contexts_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableResultTable object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableResultTable') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableResultTable') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableRowHeaders:
    """
    Row-level cells, each applicable as a header to other cells in the same row as itself,
    of the current table.

    :param str cell_id: (optional) The unique ID of the cell in the current table.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    :param str text: (optional) The textual contents of this cell from the input
          document without associated markup content.
    :param str text_normalized: (optional) Normalized row header text.
    :param int row_index_begin: (optional) The `begin` index of this cell's `row`
          location in the current table.
    :param int row_index_end: (optional) The `end` index of this cell's `row`
          location in the current table.
    :param int column_index_begin: (optional) The `begin` index of this cell's
          `column` location in the current table.
    :param int column_index_end: (optional) The `end` index of this cell's `column`
          location in the current table.
    """

    def __init__(
        self,
        *,
        cell_id: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
        text: Optional[str] = None,
        text_normalized: Optional[str] = None,
        row_index_begin: Optional[int] = None,
        row_index_end: Optional[int] = None,
        column_index_begin: Optional[int] = None,
        column_index_end: Optional[int] = None,
    ) -> None:
        """
        Initialize a TableRowHeaders object.

        :param str cell_id: (optional) The unique ID of the cell in the current
               table.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        :param str text: (optional) The textual contents of this cell from the
               input document without associated markup content.
        :param str text_normalized: (optional) Normalized row header text.
        :param int row_index_begin: (optional) The `begin` index of this cell's
               `row` location in the current table.
        :param int row_index_end: (optional) The `end` index of this cell's `row`
               location in the current table.
        :param int column_index_begin: (optional) The `begin` index of this cell's
               `column` location in the current table.
        :param int column_index_end: (optional) The `end` index of this cell's
               `column` location in the current table.
        """
        self.cell_id = cell_id
        self.location = location
        self.text = text
        self.text_normalized = text_normalized
        self.row_index_begin = row_index_begin
        self.row_index_end = row_index_end
        self.column_index_begin = column_index_begin
        self.column_index_end = column_index_end

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableRowHeaders':
        """Initialize a TableRowHeaders object from a json dictionary."""
        args = {}
        if (cell_id := _dict.get('cell_id')) is not None:
            args['cell_id'] = cell_id
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (text_normalized := _dict.get('text_normalized')) is not None:
            args['text_normalized'] = text_normalized
        if (row_index_begin := _dict.get('row_index_begin')) is not None:
            args['row_index_begin'] = row_index_begin
        if (row_index_end := _dict.get('row_index_end')) is not None:
            args['row_index_end'] = row_index_end
        if (column_index_begin := _dict.get('column_index_begin')) is not None:
            args['column_index_begin'] = column_index_begin
        if (column_index_end := _dict.get('column_index_end')) is not None:
            args['column_index_end'] = column_index_end
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableRowHeaders object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'cell_id') and self.cell_id is not None:
            _dict['cell_id'] = self.cell_id
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self,
                   'text_normalized') and self.text_normalized is not None:
            _dict['text_normalized'] = self.text_normalized
        if hasattr(self,
                   'row_index_begin') and self.row_index_begin is not None:
            _dict['row_index_begin'] = self.row_index_begin
        if hasattr(self, 'row_index_end') and self.row_index_end is not None:
            _dict['row_index_end'] = self.row_index_end
        if hasattr(
                self,
                'column_index_begin') and self.column_index_begin is not None:
            _dict['column_index_begin'] = self.column_index_begin
        if hasattr(self,
                   'column_index_end') and self.column_index_end is not None:
            _dict['column_index_end'] = self.column_index_end
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableRowHeaders object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableRowHeaders') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableRowHeaders') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TableTextLocation:
    """
    Text and associated location within a table.

    :param str text: (optional) The text retrieved.
    :param TableElementLocation location: (optional) The numeric location of the
          identified element in the document, represented with two integers labeled
          `begin` and `end`.
    """

    def __init__(
        self,
        *,
        text: Optional[str] = None,
        location: Optional['TableElementLocation'] = None,
    ) -> None:
        """
        Initialize a TableTextLocation object.

        :param str text: (optional) The text retrieved.
        :param TableElementLocation location: (optional) The numeric location of
               the identified element in the document, represented with two integers
               labeled `begin` and `end`.
        """
        self.text = text
        self.location = location

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TableTextLocation':
        """Initialize a TableTextLocation object from a json dictionary."""
        args = {}
        if (text := _dict.get('text')) is not None:
            args['text'] = text
        if (location := _dict.get('location')) is not None:
            args['location'] = TableElementLocation.from_dict(location)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TableTextLocation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self, 'location') and self.location is not None:
            if isinstance(self.location, dict):
                _dict['location'] = self.location
            else:
                _dict['location'] = self.location.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TableTextLocation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TableTextLocation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TableTextLocation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TrainingExample:
    """
    Object that contains example response details for a training query.

    :param str document_id: The document ID associated with this training example.
    :param str collection_id: The collection ID associated with this training
          example.
    :param int relevance: The relevance score of the training example. Scores range
          from `0` to `100`. Zero means not relevant. The higher the number, the more
          relevant the example.
    :param datetime created: (optional) The date and time the example was created.
    :param datetime updated: (optional) The date and time the example was updated.
    """

    def __init__(
        self,
        document_id: str,
        collection_id: str,
        relevance: int,
        *,
        created: Optional[datetime] = None,
        updated: Optional[datetime] = None,
    ) -> None:
        """
        Initialize a TrainingExample object.

        :param str document_id: The document ID associated with this training
               example.
        :param str collection_id: The collection ID associated with this training
               example.
        :param int relevance: The relevance score of the training example. Scores
               range from `0` to `100`. Zero means not relevant. The higher the number,
               the more relevant the example.
        """
        self.document_id = document_id
        self.collection_id = collection_id
        self.relevance = relevance
        self.created = created
        self.updated = updated

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TrainingExample':
        """Initialize a TrainingExample object from a json dictionary."""
        args = {}
        if (document_id := _dict.get('document_id')) is not None:
            args['document_id'] = document_id
        else:
            raise ValueError(
                'Required property \'document_id\' not present in TrainingExample JSON'
            )
        if (collection_id := _dict.get('collection_id')) is not None:
            args['collection_id'] = collection_id
        else:
            raise ValueError(
                'Required property \'collection_id\' not present in TrainingExample JSON'
            )
        if (relevance := _dict.get('relevance')) is not None:
            args['relevance'] = relevance
        else:
            raise ValueError(
                'Required property \'relevance\' not present in TrainingExample JSON'
            )
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (updated := _dict.get('updated')) is not None:
            args['updated'] = string_to_datetime(updated)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TrainingExample object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'document_id') and self.document_id is not None:
            _dict['document_id'] = self.document_id
        if hasattr(self, 'collection_id') and self.collection_id is not None:
            _dict['collection_id'] = self.collection_id
        if hasattr(self, 'relevance') and self.relevance is not None:
            _dict['relevance'] = self.relevance
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'updated') and getattr(self, 'updated') is not None:
            _dict['updated'] = datetime_to_string(getattr(self, 'updated'))
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TrainingExample object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TrainingExample') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TrainingExample') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TrainingQuery:
    """
    Object that contains training query details.

    :param str query_id: (optional) The query ID associated with the training query.
    :param str natural_language_query: The natural text query that is used as the
          training query.
    :param str filter: (optional) The filter used on the collection before the
          **natural_language_query** is applied. Only specify a filter if the documents
          that you consider to be most relevant are not included in the top 100 results
          when you submit test queries. If you specify a filter during training, apply the
          same filter to queries that are submitted at runtime for optimal ranking
          results.
    :param datetime created: (optional) The date and time the query was created.
    :param datetime updated: (optional) The date and time the query was updated.
    :param List[TrainingExample] examples: Array of training examples.
    """

    def __init__(
        self,
        natural_language_query: str,
        examples: List['TrainingExample'],
        *,
        query_id: Optional[str] = None,
        filter: Optional[str] = None,
        created: Optional[datetime] = None,
        updated: Optional[datetime] = None,
    ) -> None:
        """
        Initialize a TrainingQuery object.

        :param str natural_language_query: The natural text query that is used as
               the training query.
        :param List[TrainingExample] examples: Array of training examples.
        :param str filter: (optional) The filter used on the collection before the
               **natural_language_query** is applied. Only specify a filter if the
               documents that you consider to be most relevant are not included in the top
               100 results when you submit test queries. If you specify a filter during
               training, apply the same filter to queries that are submitted at runtime
               for optimal ranking results.
        """
        self.query_id = query_id
        self.natural_language_query = natural_language_query
        self.filter = filter
        self.created = created
        self.updated = updated
        self.examples = examples

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TrainingQuery':
        """Initialize a TrainingQuery object from a json dictionary."""
        args = {}
        if (query_id := _dict.get('query_id')) is not None:
            args['query_id'] = query_id
        if (natural_language_query :=
                _dict.get('natural_language_query')) is not None:
            args['natural_language_query'] = natural_language_query
        else:
            raise ValueError(
                'Required property \'natural_language_query\' not present in TrainingQuery JSON'
            )
        if (filter := _dict.get('filter')) is not None:
            args['filter'] = filter
        if (created := _dict.get('created')) is not None:
            args['created'] = string_to_datetime(created)
        if (updated := _dict.get('updated')) is not None:
            args['updated'] = string_to_datetime(updated)
        if (examples := _dict.get('examples')) is not None:
            args['examples'] = [TrainingExample.from_dict(v) for v in examples]
        else:
            raise ValueError(
                'Required property \'examples\' not present in TrainingQuery JSON'
            )
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TrainingQuery object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'query_id') and getattr(self, 'query_id') is not None:
            _dict['query_id'] = getattr(self, 'query_id')
        if hasattr(self, 'natural_language_query'
                  ) and self.natural_language_query is not None:
            _dict['natural_language_query'] = self.natural_language_query
        if hasattr(self, 'filter') and self.filter is not None:
            _dict['filter'] = self.filter
        if hasattr(self, 'created') and getattr(self, 'created') is not None:
            _dict['created'] = datetime_to_string(getattr(self, 'created'))
        if hasattr(self, 'updated') and getattr(self, 'updated') is not None:
            _dict['updated'] = datetime_to_string(getattr(self, 'updated'))
        if hasattr(self, 'examples') and self.examples is not None:
            examples_list = []
            for v in self.examples:
                if isinstance(v, dict):
                    examples_list.append(v)
                else:
                    examples_list.append(v.to_dict())
            _dict['examples'] = examples_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TrainingQuery object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TrainingQuery') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TrainingQuery') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class TrainingQuerySet:
    """
    Object specifying the training queries contained in the identified training set.

    :param List[TrainingQuery] queries: (optional) Array of training queries. At
          least 50 queries are required for training to begin. A maximum of 10,000 queries
          are returned.
    """

    def __init__(
        self,
        *,
        queries: Optional[List['TrainingQuery']] = None,
    ) -> None:
        """
        Initialize a TrainingQuerySet object.

        :param List[TrainingQuery] queries: (optional) Array of training queries.
               At least 50 queries are required for training to begin. A maximum of 10,000
               queries are returned.
        """
        self.queries = queries

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'TrainingQuerySet':
        """Initialize a TrainingQuerySet object from a json dictionary."""
        args = {}
        if (queries := _dict.get('queries')) is not None:
            args['queries'] = [TrainingQuery.from_dict(v) for v in queries]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a TrainingQuerySet object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'queries') and self.queries is not None:
            queries_list = []
            for v in self.queries:
                if isinstance(v, dict):
                    queries_list.append(v)
                else:
                    queries_list.append(v.to_dict())
            _dict['queries'] = queries_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this TrainingQuerySet object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'TrainingQuerySet') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'TrainingQuerySet') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class UpdateDocumentClassifier:
    """
    An object that contains a new name or description for a document classifier, updated
    training data, or new or updated test data.

    :param str name: (optional) A new name for the classifier.
    :param str description: (optional) A new description for the classifier.
    """

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        description: Optional[str] = None,
    ) -> None:
        """
        Initialize a UpdateDocumentClassifier object.

        :param str name: (optional) A new name for the classifier.
        :param str description: (optional) A new description for the classifier.
        """
        self.name = name
        self.description = description

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'UpdateDocumentClassifier':
        """Initialize a UpdateDocumentClassifier object from a json dictionary."""
        args = {}
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (description := _dict.get('description')) is not None:
            args['description'] = description
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a UpdateDocumentClassifier object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'description') and self.description is not None:
            _dict['description'] = self.description
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this UpdateDocumentClassifier object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'UpdateDocumentClassifier') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'UpdateDocumentClassifier') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class WebhookHeader:
    """
    An array of headers to pass with the HTTP request. Optional when `type` is `webhook`.
    Not valid when creating any other type of enrichment.

    :param str name: The name of an HTTP header.
    :param str value: The value of an HTTP header.
    """

    def __init__(
        self,
        name: str,
        value: str,
    ) -> None:
        """
        Initialize a WebhookHeader object.

        :param str name: The name of an HTTP header.
        :param str value: The value of an HTTP header.
        """
        self.name = name
        self.value = value

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'WebhookHeader':
        """Initialize a WebhookHeader object from a json dictionary."""
        args = {}
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        else:
            raise ValueError(
                'Required property \'name\' not present in WebhookHeader JSON')
        if (value := _dict.get('value')) is not None:
            args['value'] = value
        else:
            raise ValueError(
                'Required property \'value\' not present in WebhookHeader JSON')
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a WebhookHeader object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'value') and self.value is not None:
            _dict['value'] = self.value
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this WebhookHeader object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'WebhookHeader') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'WebhookHeader') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class PullBatchesResponse:
    """
    A compressed newline delimited JSON (NDJSON) file containing the document. The NDJSON
    format is used to describe structured data. The file name format is
    `{batch_id}.ndjson.gz`. For more information, see [Binary attachment from the pull
    batches
    method](/docs/discovery-data?topic=discovery-data-external-enrichment#binary-attachment-pull-batches).

    :param str file: (optional) A compressed NDJSON file containing the document.
    """

    def __init__(
        self,
        *,
        file: Optional[str] = None,
    ) -> None:
        """
        Initialize a PullBatchesResponse object.

        :param str file: (optional) A compressed NDJSON file containing the
               document.
        """
        self.file = file

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'PullBatchesResponse':
        """Initialize a PullBatchesResponse object from a json dictionary."""
        args = {}
        if (file := _dict.get('file')) is not None:
            args['file'] = file
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a PullBatchesResponse object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'file') and self.file is not None:
            _dict['file'] = self.file
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this PullBatchesResponse object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'PullBatchesResponse') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'PullBatchesResponse') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryCalculationAggregation(QueryAggregation):
    """
    Returns a scalar calculation across all documents for the field specified. Possible
    calculations include min, max, sum, average, and unique_count.

    :param str type: (optional) Specifies the calculation type, such as 'average`,
          `max`, `min`, `sum`, or `unique_count`.
    :param str field: The field to perform the calculation on.
    :param float value: (optional) The value of the calculation.
    """

    def __init__(
        self,
        field: str,
        *,
        type: Optional[str] = None,
        value: Optional[float] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryCalculationAggregation object.

        :param str field: The field to perform the calculation on.
        :param str type: (optional) Specifies the calculation type, such as
               'average`, `max`, `min`, `sum`, or `unique_count`.
        :param float value: (optional) The value of the calculation.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.field = field
        self.value = value

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'QueryAggregationQueryCalculationAggregation':
        """Initialize a QueryAggregationQueryCalculationAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        else:
            raise ValueError(
                'Required property \'field\' not present in QueryAggregationQueryCalculationAggregation JSON'
            )
        if (value := _dict.get('value')) is not None:
            args['value'] = value
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryCalculationAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        if hasattr(self, 'value') and self.value is not None:
            _dict['value'] = self.value
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryCalculationAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self,
               other: 'QueryAggregationQueryCalculationAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self,
               other: 'QueryAggregationQueryCalculationAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryFilterAggregation(QueryAggregation):
    """
    A modifier that narrows the document set of the subaggregations it precedes.

    :param str type: (optional) Specifies that the aggregation type is `filter`.
    :param str match: The filter that is written in Discovery Query Language syntax
          and is applied to the documents before subaggregations are run.
    :param int matching_results: Number of documents that match the filter.
    :param List[dict] aggregations: (optional) An array of subaggregations.
    """

    def __init__(
        self,
        match: str,
        matching_results: int,
        *,
        type: Optional[str] = None,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryFilterAggregation object.

        :param str match: The filter that is written in Discovery Query Language
               syntax and is applied to the documents before subaggregations are run.
        :param int matching_results: Number of documents that match the filter.
        :param str type: (optional) Specifies that the aggregation type is
               `filter`.
        :param List[dict] aggregations: (optional) An array of subaggregations.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.match = match
        self.matching_results = matching_results
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregationQueryFilterAggregation':
        """Initialize a QueryAggregationQueryFilterAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (match := _dict.get('match')) is not None:
            args['match'] = match
        else:
            raise ValueError(
                'Required property \'match\' not present in QueryAggregationQueryFilterAggregation JSON'
            )
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryAggregationQueryFilterAggregation JSON'
            )
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryFilterAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'match') and self.match is not None:
            _dict['match'] = self.match
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryFilterAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryFilterAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryFilterAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryGroupByAggregation(QueryAggregation):
    """
    Separates document results into groups that meet the conditions you specify.

    :param str type: (optional) Specifies that the aggregation type is `group_by`.
    :param List[QueryGroupByAggregationResult] results: (optional) An array of
          results.
    """

    def __init__(
        self,
        *,
        type: Optional[str] = None,
        results: Optional[List['QueryGroupByAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryGroupByAggregation object.

        :param str type: (optional) Specifies that the aggregation type is
               `group_by`.
        :param List[QueryGroupByAggregationResult] results: (optional) An array of
               results.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.results = results

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'QueryAggregationQueryGroupByAggregation':
        """Initialize a QueryAggregationQueryGroupByAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryGroupByAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryGroupByAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryGroupByAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryGroupByAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryGroupByAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryHistogramAggregation(QueryAggregation):
    """
    Numeric interval segments to categorize documents by using field values from a single
    numeric field to describe the category.

    :param str type: (optional) Specifies that the aggregation type is `histogram`.
    :param str field: The numeric field name used to create the histogram.
    :param int interval: The size of the sections that the results are split into.
    :param str name: (optional) Identifier that can optionally be specified in the
          query request of this aggregation.
    :param List[QueryHistogramAggregationResult] results: (optional) Array of
          numeric intervals.
    """

    def __init__(
        self,
        field: str,
        interval: int,
        *,
        type: Optional[str] = None,
        name: Optional[str] = None,
        results: Optional[List['QueryHistogramAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryHistogramAggregation object.

        :param str field: The numeric field name used to create the histogram.
        :param int interval: The size of the sections that the results are split
               into.
        :param str type: (optional) Specifies that the aggregation type is
               `histogram`.
        :param str name: (optional) Identifier that can optionally be specified in
               the query request of this aggregation.
        :param List[QueryHistogramAggregationResult] results: (optional) Array of
               numeric intervals.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.field = field
        self.interval = interval
        self.name = name
        self.results = results

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'QueryAggregationQueryHistogramAggregation':
        """Initialize a QueryAggregationQueryHistogramAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        else:
            raise ValueError(
                'Required property \'field\' not present in QueryAggregationQueryHistogramAggregation JSON'
            )
        if (interval := _dict.get('interval')) is not None:
            args['interval'] = interval
        else:
            raise ValueError(
                'Required property \'interval\' not present in QueryAggregationQueryHistogramAggregation JSON'
            )
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryHistogramAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryHistogramAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        if hasattr(self, 'interval') and self.interval is not None:
            _dict['interval'] = self.interval
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryHistogramAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self,
               other: 'QueryAggregationQueryHistogramAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self,
               other: 'QueryAggregationQueryHistogramAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryNestedAggregation(QueryAggregation):
    """
    A restriction that alters the document set that is used by the aggregations that it
    precedes. Subsequent aggregations are applied to nested documents from the specified
    field.

    :param str type: (optional) Specifies that the aggregation type is `nested`.
    :param str path: The path to the document field to scope subsequent aggregations
          to.
    :param int matching_results: Number of nested documents found in the specified
          field.
    :param List[dict] aggregations: (optional) An array of subaggregations.
    """

    def __init__(
        self,
        path: str,
        matching_results: int,
        *,
        type: Optional[str] = None,
        aggregations: Optional[List[dict]] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryNestedAggregation object.

        :param str path: The path to the document field to scope subsequent
               aggregations to.
        :param int matching_results: Number of nested documents found in the
               specified field.
        :param str type: (optional) Specifies that the aggregation type is
               `nested`.
        :param List[dict] aggregations: (optional) An array of subaggregations.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.path = path
        self.matching_results = matching_results
        self.aggregations = aggregations

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregationQueryNestedAggregation':
        """Initialize a QueryAggregationQueryNestedAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (path := _dict.get('path')) is not None:
            args['path'] = path
        else:
            raise ValueError(
                'Required property \'path\' not present in QueryAggregationQueryNestedAggregation JSON'
            )
        if (matching_results := _dict.get('matching_results')) is not None:
            args['matching_results'] = matching_results
        else:
            raise ValueError(
                'Required property \'matching_results\' not present in QueryAggregationQueryNestedAggregation JSON'
            )
        if (aggregations := _dict.get('aggregations')) is not None:
            args['aggregations'] = aggregations
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryNestedAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'path') and self.path is not None:
            _dict['path'] = self.path
        if hasattr(self,
                   'matching_results') and self.matching_results is not None:
            _dict['matching_results'] = self.matching_results
        if hasattr(self, 'aggregations') and self.aggregations is not None:
            _dict['aggregations'] = self.aggregations
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryNestedAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryNestedAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryNestedAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryPairAggregation(QueryAggregation):
    """
    Calculates relevancy values using combinations of document sets from results of the
    specified pair of aggregations.

    :param str type: (optional) Specifies that the aggregation type is `pair`.
    :param str first: (optional) Specifies the first aggregation in the pair. The
          aggregation must be a `term`, `group_by`, `histogram`, or `timeslice`
          aggregation type.
    :param str second: (optional) Specifies the second aggregation in the pair. The
          aggregation must be a `term`, `group_by`, `histogram`, or `timeslice`
          aggregation type.
    :param bool show_estimated_matching_results: (optional) Indicates whether to
          include estimated matching result information.
    :param bool show_total_matching_documents: (optional) Indicates whether to
          include total matching documents information.
    :param List[QueryPairAggregationResult] results: (optional) An array of
          aggregations.
    """

    def __init__(
        self,
        *,
        type: Optional[str] = None,
        first: Optional[str] = None,
        second: Optional[str] = None,
        show_estimated_matching_results: Optional[bool] = None,
        show_total_matching_documents: Optional[bool] = None,
        results: Optional[List['QueryPairAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryPairAggregation object.

        :param str type: (optional) Specifies that the aggregation type is `pair`.
        :param str first: (optional) Specifies the first aggregation in the pair.
               The aggregation must be a `term`, `group_by`, `histogram`, or `timeslice`
               aggregation type.
        :param str second: (optional) Specifies the second aggregation in the pair.
               The aggregation must be a `term`, `group_by`, `histogram`, or `timeslice`
               aggregation type.
        :param bool show_estimated_matching_results: (optional) Indicates whether
               to include estimated matching result information.
        :param bool show_total_matching_documents: (optional) Indicates whether to
               include total matching documents information.
        :param List[QueryPairAggregationResult] results: (optional) An array of
               aggregations.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.first = first
        self.second = second
        self.show_estimated_matching_results = show_estimated_matching_results
        self.show_total_matching_documents = show_total_matching_documents
        self.results = results

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregationQueryPairAggregation':
        """Initialize a QueryAggregationQueryPairAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (first := _dict.get('first')) is not None:
            args['first'] = first
        if (second := _dict.get('second')) is not None:
            args['second'] = second
        if (show_estimated_matching_results :=
                _dict.get('show_estimated_matching_results')) is not None:
            args[
                'show_estimated_matching_results'] = show_estimated_matching_results
        if (show_total_matching_documents :=
                _dict.get('show_total_matching_documents')) is not None:
            args[
                'show_total_matching_documents'] = show_total_matching_documents
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryPairAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryPairAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'first') and self.first is not None:
            _dict['first'] = self.first
        if hasattr(self, 'second') and self.second is not None:
            _dict['second'] = self.second
        if hasattr(self, 'show_estimated_matching_results'
                  ) and self.show_estimated_matching_results is not None:
            _dict[
                'show_estimated_matching_results'] = self.show_estimated_matching_results
        if hasattr(self, 'show_total_matching_documents'
                  ) and self.show_total_matching_documents is not None:
            _dict[
                'show_total_matching_documents'] = self.show_total_matching_documents
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryPairAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryPairAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryPairAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryTermAggregation(QueryAggregation):
    """
    Returns results from the field that is specified.

    :param str type: (optional) Specifies that the aggregation type is `term`.
    :param str field: (optional) The field in the document where the values come
          from.
    :param int count: (optional) The number of results returned. Not returned if
          `relevancy:true` is specified in the request.
    :param str name: (optional) Identifier specified in the query request of this
          aggregation. Not returned if `relevancy:true` is specified in the request.
    :param List[QueryTermAggregationResult] results: (optional) An array of results.
    """

    def __init__(
        self,
        *,
        type: Optional[str] = None,
        field: Optional[str] = None,
        count: Optional[int] = None,
        name: Optional[str] = None,
        results: Optional[List['QueryTermAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryTermAggregation object.

        :param str type: (optional) Specifies that the aggregation type is `term`.
        :param str field: (optional) The field in the document where the values
               come from.
        :param int count: (optional) The number of results returned. Not returned
               if `relevancy:true` is specified in the request.
        :param str name: (optional) Identifier specified in the query request of
               this aggregation. Not returned if `relevancy:true` is specified in the
               request.
        :param List[QueryTermAggregationResult] results: (optional) An array of
               results.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.field = field
        self.count = count
        self.name = name
        self.results = results

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregationQueryTermAggregation':
        """Initialize a QueryAggregationQueryTermAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        if (count := _dict.get('count')) is not None:
            args['count'] = count
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryTermAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryTermAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        if hasattr(self, 'count') and self.count is not None:
            _dict['count'] = self.count
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryTermAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryTermAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryTermAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryTimesliceAggregation(QueryAggregation):
    """
    A specialized histogram aggregation that uses dates to create interval segments.

    :param str type: (optional) Specifies that the aggregation type is `timeslice`.
    :param str field: The date field name used to create the timeslice.
    :param str interval: The date interval value. Valid values are seconds, minutes,
          hours, days, weeks, and years.
    :param str name: (optional) Identifier that can optionally be specified in the
          query request of this aggregation.
    :param List[QueryTimesliceAggregationResult] results: (optional) Array of
          aggregation results.
    """

    def __init__(
        self,
        field: str,
        interval: str,
        *,
        type: Optional[str] = None,
        name: Optional[str] = None,
        results: Optional[List['QueryTimesliceAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryTimesliceAggregation object.

        :param str field: The date field name used to create the timeslice.
        :param str interval: The date interval value. Valid values are seconds,
               minutes, hours, days, weeks, and years.
        :param str type: (optional) Specifies that the aggregation type is
               `timeslice`.
        :param str name: (optional) Identifier that can optionally be specified in
               the query request of this aggregation.
        :param List[QueryTimesliceAggregationResult] results: (optional) Array of
               aggregation results.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.field = field
        self.interval = interval
        self.name = name
        self.results = results

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'QueryAggregationQueryTimesliceAggregation':
        """Initialize a QueryAggregationQueryTimesliceAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (field := _dict.get('field')) is not None:
            args['field'] = field
        else:
            raise ValueError(
                'Required property \'field\' not present in QueryAggregationQueryTimesliceAggregation JSON'
            )
        if (interval := _dict.get('interval')) is not None:
            args['interval'] = interval
        else:
            raise ValueError(
                'Required property \'interval\' not present in QueryAggregationQueryTimesliceAggregation JSON'
            )
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryTimesliceAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryTimesliceAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        if hasattr(self, 'interval') and self.interval is not None:
            _dict['interval'] = self.interval
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryTimesliceAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self,
               other: 'QueryAggregationQueryTimesliceAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self,
               other: 'QueryAggregationQueryTimesliceAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryTopHitsAggregation(QueryAggregation):
    """
    Returns the top documents ranked by the score of the query.

    :param str type: (optional) Specifies that the aggregation type is `top_hits`.
    :param int size: The number of documents to return.
    :param str name: (optional) Identifier specified in the query request of this
          aggregation.
    :param QueryTopHitsAggregationResult hits: (optional) A query response that
          contains the matching documents for the preceding aggregations.
    """

    def __init__(
        self,
        size: int,
        *,
        type: Optional[str] = None,
        name: Optional[str] = None,
        hits: Optional['QueryTopHitsAggregationResult'] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryTopHitsAggregation object.

        :param int size: The number of documents to return.
        :param str type: (optional) Specifies that the aggregation type is
               `top_hits`.
        :param str name: (optional) Identifier specified in the query request of
               this aggregation.
        :param QueryTopHitsAggregationResult hits: (optional) A query response that
               contains the matching documents for the preceding aggregations.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.size = size
        self.name = name
        self.hits = hits

    @classmethod
    def from_dict(cls,
                  _dict: Dict) -> 'QueryAggregationQueryTopHitsAggregation':
        """Initialize a QueryAggregationQueryTopHitsAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (size := _dict.get('size')) is not None:
            args['size'] = size
        else:
            raise ValueError(
                'Required property \'size\' not present in QueryAggregationQueryTopHitsAggregation JSON'
            )
        if (name := _dict.get('name')) is not None:
            args['name'] = name
        if (hits := _dict.get('hits')) is not None:
            args['hits'] = QueryTopHitsAggregationResult.from_dict(hits)
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryTopHitsAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'size') and self.size is not None:
            _dict['size'] = self.size
        if hasattr(self, 'name') and self.name is not None:
            _dict['name'] = self.name
        if hasattr(self, 'hits') and self.hits is not None:
            if isinstance(self.hits, dict):
                _dict['hits'] = self.hits
            else:
                _dict['hits'] = self.hits.to_dict()
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryTopHitsAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryTopHitsAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryTopHitsAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryTopicAggregation(QueryAggregation):
    """
    Detects how much the frequency of a given facet value deviates from the expected
    average for the given time period. This aggregation type does not use data from
    previous time periods. It calculates an index by using the averages of frequency
    counts of other facet values for the given time period.

    :param str type: (optional) Specifies that the aggregation type is `topic`.
    :param str facet: (optional) Specifies the `term` or `group_by` aggregation for
          the facet that you want to analyze.
    :param str time_segments: (optional) Specifies the `timeslice` aggregation that
          defines the time segments.
    :param bool show_estimated_matching_results: (optional) Indicates whether to
          include estimated matching result information.
    :param bool show_total_matching_documents: (optional) Indicates whether to
          include total matching documents information.
    :param List[QueryTopicAggregationResult] results: (optional) An array of
          aggregations.
    """

    def __init__(
        self,
        *,
        type: Optional[str] = None,
        facet: Optional[str] = None,
        time_segments: Optional[str] = None,
        show_estimated_matching_results: Optional[bool] = None,
        show_total_matching_documents: Optional[bool] = None,
        results: Optional[List['QueryTopicAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryTopicAggregation object.

        :param str type: (optional) Specifies that the aggregation type is `topic`.
        :param str facet: (optional) Specifies the `term` or `group_by` aggregation
               for the facet that you want to analyze.
        :param str time_segments: (optional) Specifies the `timeslice` aggregation
               that defines the time segments.
        :param bool show_estimated_matching_results: (optional) Indicates whether
               to include estimated matching result information.
        :param bool show_total_matching_documents: (optional) Indicates whether to
               include total matching documents information.
        :param List[QueryTopicAggregationResult] results: (optional) An array of
               aggregations.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.facet = facet
        self.time_segments = time_segments
        self.show_estimated_matching_results = show_estimated_matching_results
        self.show_total_matching_documents = show_total_matching_documents
        self.results = results

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregationQueryTopicAggregation':
        """Initialize a QueryAggregationQueryTopicAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (facet := _dict.get('facet')) is not None:
            args['facet'] = facet
        if (time_segments := _dict.get('time_segments')) is not None:
            args['time_segments'] = time_segments
        if (show_estimated_matching_results :=
                _dict.get('show_estimated_matching_results')) is not None:
            args[
                'show_estimated_matching_results'] = show_estimated_matching_results
        if (show_total_matching_documents :=
                _dict.get('show_total_matching_documents')) is not None:
            args[
                'show_total_matching_documents'] = show_total_matching_documents
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryTopicAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryTopicAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'facet') and self.facet is not None:
            _dict['facet'] = self.facet
        if hasattr(self, 'time_segments') and self.time_segments is not None:
            _dict['time_segments'] = self.time_segments
        if hasattr(self, 'show_estimated_matching_results'
                  ) and self.show_estimated_matching_results is not None:
            _dict[
                'show_estimated_matching_results'] = self.show_estimated_matching_results
        if hasattr(self, 'show_total_matching_documents'
                  ) and self.show_total_matching_documents is not None:
            _dict[
                'show_total_matching_documents'] = self.show_total_matching_documents
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryTopicAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryTopicAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryTopicAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other


class QueryAggregationQueryTrendAggregation(QueryAggregation):
    """
    Detects sharp and unexpected changes in the frequency of a facet or facet value over
    time based on the past history of frequency changes of the facet value.

    :param str type: (optional) Specifies that the aggregation type is `trend`.
    :param str facet: (optional) Specifies the `term` or `group_by` aggregation for
          the facet that you want to analyze.
    :param str time_segments: (optional) Specifies the `timeslice` aggregation that
          defines the time segments.
    :param bool show_estimated_matching_results: (optional) Indicates whether to
          include estimated matching result information.
    :param bool show_total_matching_documents: (optional) Indicates whether to
          include total matching documents information.
    :param List[QueryTrendAggregationResult] results: (optional) An array of
          aggregations.
    """

    def __init__(
        self,
        *,
        type: Optional[str] = None,
        facet: Optional[str] = None,
        time_segments: Optional[str] = None,
        show_estimated_matching_results: Optional[bool] = None,
        show_total_matching_documents: Optional[bool] = None,
        results: Optional[List['QueryTrendAggregationResult']] = None,
    ) -> None:
        """
        Initialize a QueryAggregationQueryTrendAggregation object.

        :param str type: (optional) Specifies that the aggregation type is `trend`.
        :param str facet: (optional) Specifies the `term` or `group_by` aggregation
               for the facet that you want to analyze.
        :param str time_segments: (optional) Specifies the `timeslice` aggregation
               that defines the time segments.
        :param bool show_estimated_matching_results: (optional) Indicates whether
               to include estimated matching result information.
        :param bool show_total_matching_documents: (optional) Indicates whether to
               include total matching documents information.
        :param List[QueryTrendAggregationResult] results: (optional) An array of
               aggregations.
        """
        # pylint: disable=super-init-not-called
        self.type = type
        self.facet = facet
        self.time_segments = time_segments
        self.show_estimated_matching_results = show_estimated_matching_results
        self.show_total_matching_documents = show_total_matching_documents
        self.results = results

    @classmethod
    def from_dict(cls, _dict: Dict) -> 'QueryAggregationQueryTrendAggregation':
        """Initialize a QueryAggregationQueryTrendAggregation object from a json dictionary."""
        args = {}
        if (type := _dict.get('type')) is not None:
            args['type'] = type
        if (facet := _dict.get('facet')) is not None:
            args['facet'] = facet
        if (time_segments := _dict.get('time_segments')) is not None:
            args['time_segments'] = time_segments
        if (show_estimated_matching_results :=
                _dict.get('show_estimated_matching_results')) is not None:
            args[
                'show_estimated_matching_results'] = show_estimated_matching_results
        if (show_total_matching_documents :=
                _dict.get('show_total_matching_documents')) is not None:
            args[
                'show_total_matching_documents'] = show_total_matching_documents
        if (results := _dict.get('results')) is not None:
            args['results'] = [
                QueryTrendAggregationResult.from_dict(v) for v in results
            ]
        return cls(**args)

    @classmethod
    def _from_dict(cls, _dict):
        """Initialize a QueryAggregationQueryTrendAggregation object from a json dictionary."""
        return cls.from_dict(_dict)

    def to_dict(self) -> Dict:
        """Return a json dictionary representing this model."""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'facet') and self.facet is not None:
            _dict['facet'] = self.facet
        if hasattr(self, 'time_segments') and self.time_segments is not None:
            _dict['time_segments'] = self.time_segments
        if hasattr(self, 'show_estimated_matching_results'
                  ) and self.show_estimated_matching_results is not None:
            _dict[
                'show_estimated_matching_results'] = self.show_estimated_matching_results
        if hasattr(self, 'show_total_matching_documents'
                  ) and self.show_total_matching_documents is not None:
            _dict[
                'show_total_matching_documents'] = self.show_total_matching_documents
        if hasattr(self, 'results') and self.results is not None:
            results_list = []
            for v in self.results:
                if isinstance(v, dict):
                    results_list.append(v)
                else:
                    results_list.append(v.to_dict())
            _dict['results'] = results_list
        return _dict

    def _to_dict(self):
        """Return a json dictionary representing this model."""
        return self.to_dict()

    def __str__(self) -> str:
        """Return a `str` version of this QueryAggregationQueryTrendAggregation object."""
        return json.dumps(self.to_dict(), indent=2)

    def __eq__(self, other: 'QueryAggregationQueryTrendAggregation') -> bool:
        """Return `true` when self and other are equal, false otherwise."""
        if not isinstance(other, self.__class__):
            return False
        return self.__dict__ == other.__dict__

    def __ne__(self, other: 'QueryAggregationQueryTrendAggregation') -> bool:
        """Return `true` when self and other are not equal, false otherwise."""
        return not self == other
