# coding: utf-8

"""
    Snowstorm

    SNOMED CT Terminology Server REST API

    The version of the OpenAPI document: 10.8.2
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501

import warnings
from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
from typing import Any, Dict, List, Optional, Tuple, Union
from typing_extensions import Annotated

from pydantic import Field, StrictBool, StrictInt, StrictStr
from typing import List, Optional
from typing_extensions import Annotated
from snowstorm_client.models.concept_mini_component import ConceptMiniComponent
from snowstorm_client.models.items_page_identifier_component import ItemsPageIdentifierComponent

from snowstorm_client.api_client import ApiClient, RequestSerialized
from snowstorm_client.api_response import ApiResponse
from snowstorm_client.rest import RESTResponseType


class IdentifiersApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def find_identifier_referenced_concept(
        self,
        branch: StrictStr,
        alternate_identifier: StrictStr,
        accept_language: Annotated[Optional[StrictStr], Field(description="Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ConceptMiniComponent:
        """find_identifier_referenced_concept


        :param branch: (required)
        :type branch: str
        :param alternate_identifier: (required)
        :type alternate_identifier: str
        :param accept_language: Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.
        :type accept_language: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_identifier_referenced_concept_serialize(
            branch=branch,
            alternate_identifier=alternate_identifier,
            accept_language=accept_language,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ConceptMiniComponent",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def find_identifier_referenced_concept_with_http_info(
        self,
        branch: StrictStr,
        alternate_identifier: StrictStr,
        accept_language: Annotated[Optional[StrictStr], Field(description="Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ConceptMiniComponent]:
        """find_identifier_referenced_concept


        :param branch: (required)
        :type branch: str
        :param alternate_identifier: (required)
        :type alternate_identifier: str
        :param accept_language: Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.
        :type accept_language: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_identifier_referenced_concept_serialize(
            branch=branch,
            alternate_identifier=alternate_identifier,
            accept_language=accept_language,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ConceptMiniComponent",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def find_identifier_referenced_concept_without_preload_content(
        self,
        branch: StrictStr,
        alternate_identifier: StrictStr,
        accept_language: Annotated[Optional[StrictStr], Field(description="Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """find_identifier_referenced_concept


        :param branch: (required)
        :type branch: str
        :param alternate_identifier: (required)
        :type alternate_identifier: str
        :param accept_language: Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.
        :type accept_language: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_identifier_referenced_concept_serialize(
            branch=branch,
            alternate_identifier=alternate_identifier,
            accept_language=accept_language,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ConceptMiniComponent",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _find_identifier_referenced_concept_serialize(
        self,
        branch,
        alternate_identifier,
        accept_language,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if branch is not None:
            _path_params['branch'] = branch
        if alternate_identifier is not None:
            _path_params['alternateIdentifier'] = alternate_identifier
        # process the query parameters
        # process the header parameters
        if accept_language is not None:
            _header_params['Accept-Language'] = accept_language
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json', 
                    'text/csv'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/{branch}/identifiers/{alternateIdentifier}/referenced-concept',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def find_identifiers(
        self,
        branch: StrictStr,
        alternate_identifier: Optional[StrictStr] = None,
        identifier_scheme_id: Optional[StrictStr] = None,
        active_filter: Optional[StrictBool] = None,
        is_null_effective_time: Optional[StrictBool] = None,
        module: Optional[StrictStr] = None,
        referenced_component_ids: Optional[List[StrictStr]] = None,
        offset: Optional[StrictInt] = None,
        limit: Optional[StrictInt] = None,
        search_after: Optional[StrictStr] = None,
        accept_language: Annotated[Optional[StrictStr], Field(description="Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ItemsPageIdentifierComponent:
        """find_identifiers


        :param branch: (required)
        :type branch: str
        :param alternate_identifier:
        :type alternate_identifier: str
        :param identifier_scheme_id:
        :type identifier_scheme_id: str
        :param active_filter:
        :type active_filter: bool
        :param is_null_effective_time:
        :type is_null_effective_time: bool
        :param module:
        :type module: str
        :param referenced_component_ids:
        :type referenced_component_ids: List[str]
        :param offset:
        :type offset: int
        :param limit:
        :type limit: int
        :param search_after:
        :type search_after: str
        :param accept_language: Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.
        :type accept_language: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_identifiers_serialize(
            branch=branch,
            alternate_identifier=alternate_identifier,
            identifier_scheme_id=identifier_scheme_id,
            active_filter=active_filter,
            is_null_effective_time=is_null_effective_time,
            module=module,
            referenced_component_ids=referenced_component_ids,
            offset=offset,
            limit=limit,
            search_after=search_after,
            accept_language=accept_language,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ItemsPageIdentifierComponent",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def find_identifiers_with_http_info(
        self,
        branch: StrictStr,
        alternate_identifier: Optional[StrictStr] = None,
        identifier_scheme_id: Optional[StrictStr] = None,
        active_filter: Optional[StrictBool] = None,
        is_null_effective_time: Optional[StrictBool] = None,
        module: Optional[StrictStr] = None,
        referenced_component_ids: Optional[List[StrictStr]] = None,
        offset: Optional[StrictInt] = None,
        limit: Optional[StrictInt] = None,
        search_after: Optional[StrictStr] = None,
        accept_language: Annotated[Optional[StrictStr], Field(description="Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ItemsPageIdentifierComponent]:
        """find_identifiers


        :param branch: (required)
        :type branch: str
        :param alternate_identifier:
        :type alternate_identifier: str
        :param identifier_scheme_id:
        :type identifier_scheme_id: str
        :param active_filter:
        :type active_filter: bool
        :param is_null_effective_time:
        :type is_null_effective_time: bool
        :param module:
        :type module: str
        :param referenced_component_ids:
        :type referenced_component_ids: List[str]
        :param offset:
        :type offset: int
        :param limit:
        :type limit: int
        :param search_after:
        :type search_after: str
        :param accept_language: Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.
        :type accept_language: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_identifiers_serialize(
            branch=branch,
            alternate_identifier=alternate_identifier,
            identifier_scheme_id=identifier_scheme_id,
            active_filter=active_filter,
            is_null_effective_time=is_null_effective_time,
            module=module,
            referenced_component_ids=referenced_component_ids,
            offset=offset,
            limit=limit,
            search_after=search_after,
            accept_language=accept_language,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ItemsPageIdentifierComponent",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def find_identifiers_without_preload_content(
        self,
        branch: StrictStr,
        alternate_identifier: Optional[StrictStr] = None,
        identifier_scheme_id: Optional[StrictStr] = None,
        active_filter: Optional[StrictBool] = None,
        is_null_effective_time: Optional[StrictBool] = None,
        module: Optional[StrictStr] = None,
        referenced_component_ids: Optional[List[StrictStr]] = None,
        offset: Optional[StrictInt] = None,
        limit: Optional[StrictInt] = None,
        search_after: Optional[StrictStr] = None,
        accept_language: Annotated[Optional[StrictStr], Field(description="Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """find_identifiers


        :param branch: (required)
        :type branch: str
        :param alternate_identifier:
        :type alternate_identifier: str
        :param identifier_scheme_id:
        :type identifier_scheme_id: str
        :param active_filter:
        :type active_filter: bool
        :param is_null_effective_time:
        :type is_null_effective_time: bool
        :param module:
        :type module: str
        :param referenced_component_ids:
        :type referenced_component_ids: List[str]
        :param offset:
        :type offset: int
        :param limit:
        :type limit: int
        :param search_after:
        :type search_after: str
        :param accept_language: Accept-Language header can take the format en-x-900000000000508004 which sets the language reference set to use in the results.
        :type accept_language: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_identifiers_serialize(
            branch=branch,
            alternate_identifier=alternate_identifier,
            identifier_scheme_id=identifier_scheme_id,
            active_filter=active_filter,
            is_null_effective_time=is_null_effective_time,
            module=module,
            referenced_component_ids=referenced_component_ids,
            offset=offset,
            limit=limit,
            search_after=search_after,
            accept_language=accept_language,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ItemsPageIdentifierComponent",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _find_identifiers_serialize(
        self,
        branch,
        alternate_identifier,
        identifier_scheme_id,
        active_filter,
        is_null_effective_time,
        module,
        referenced_component_ids,
        offset,
        limit,
        search_after,
        accept_language,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'referencedComponentIds': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if branch is not None:
            _path_params['branch'] = branch
        # process the query parameters
        if alternate_identifier is not None:
            
            _query_params.append(('alternateIdentifier', alternate_identifier))
            
        if identifier_scheme_id is not None:
            
            _query_params.append(('identifierSchemeId', identifier_scheme_id))
            
        if active_filter is not None:
            
            _query_params.append(('activeFilter', active_filter))
            
        if is_null_effective_time is not None:
            
            _query_params.append(('isNullEffectiveTime', is_null_effective_time))
            
        if module is not None:
            
            _query_params.append(('module', module))
            
        if referenced_component_ids is not None:
            
            _query_params.append(('referencedComponentIds', referenced_component_ids))
            
        if offset is not None:
            
            _query_params.append(('offset', offset))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if search_after is not None:
            
            _query_params.append(('searchAfter', search_after))
            
        # process the header parameters
        if accept_language is not None:
            _header_params['Accept-Language'] = accept_language
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json', 
                    'text/csv'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/{branch}/identifiers',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )


