# coding: utf-8

"""
    Acre Platform User API

    # CORS CORS is implemented by all Acre API endpoints and only certain hostnames are allowed for each deployment of the API. If your use case requires calling the Acre User API from a browser, please contact Acre to arrange the appropriate configuration. # API Authentication The primary method of authentication for users of the Acre API is with the use of JSON Web Tokens (JWTs), which are suplemented by an application specific API Key. The API key must be provided through the `X-API-KEY` HTTP header and will be provided by your Acre Customer Success Manager. The JWT must be provided through a cookie with key of `authorization`. The JWT must be generated and signed as per the following section. # Generating JWTs JWT must either be generated by a third-party such as Azure ADB2C that has been configured for the appropriate service and/or user account, or alternatively can be generated locally and signed by an private key for which the public key has been made available to Acre via a JWKS URL. In addition to being signed by your private key, the JWT will also need to contain at a minimum:  * An issuer `iss`, which must be a valid URI previously agreed with Acre.  * A subject `sub`, which must be a unique identifier for the user and/or service account previously agreed with Acre.  * An expiry time `exp` which must not be more than four hours in the future.  * A not before time `nbf` which must be in the past, but not greater than six hours in the past.  The JWT should be signed using RS256.

    The version of the OpenAPI document: 1.0
    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, field_validator
from typing import List, Optional
from typing_extensions import Annotated
from acre_api.models.acre_processor_update_case_status_body import AcreProcessorUpdateCaseStatusBody
from acre_api.models.cdm_bulk_assign_case_request import CdmBulkAssignCaseRequest
from acre_api.models.cdm_bulk_assign_case_response import CdmBulkAssignCaseResponse
from acre_api.models.cdm_bulk_create_lead_cases_request import CdmBulkCreateLeadCasesRequest
from acre_api.models.cdm_bulk_create_lead_cases_response import CdmBulkCreateLeadCasesResponse
from acre_api.models.cdm_create_case_flag_response import CdmCreateCaseFlagResponse
from acre_api.models.cdm_create_case_flag_review_response import CdmCreateCaseFlagReviewResponse
from acre_api.models.cdm_create_case_referral_request import CdmCreateCaseReferralRequest
from acre_api.models.cdm_create_case_request import CdmCreateCaseRequest
from acre_api.models.cdm_create_case_response import CdmCreateCaseResponse
from acre_api.models.cdm_create_case_version_response import CdmCreateCaseVersionResponse
from acre_api.models.cdm_describe_case_verification_response import CdmDescribeCaseVerificationResponse
from acre_api.models.cdm_get_case_response import CdmGetCaseResponse
from acre_api.models.cdm_get_case_survey_response import CdmGetCaseSurveyResponse
from acre_api.models.cdm_get_case_verifications_response import CdmGetCaseVerificationsResponse
from acre_api.models.cdm_get_case_version_response import CdmGetCaseVersionResponse
from acre_api.models.cdm_hydrated_case_response import CdmHydratedCaseResponse
from acre_api.models.cdm_list_case_version_response import CdmListCaseVersionResponse
from acre_api.models.cdm_replace_case_response import CdmReplaceCaseResponse
from acre_api.models.cdm_review_body import CdmReviewBody
from acre_api.models.cdm_update_case_response import CdmUpdateCaseResponse
from acre_api.models.cdm_update_case_status_response import CdmUpdateCaseStatusResponse
from acre_api.models.minimal_details_of_flag_to_add_required import MinimalDetailsOfFlagToAddRequired
from acre_api.models.partial_details_of_the_case_to_be_patched_required import PartialDetailsOfTheCaseToBePatchedRequired
from acre_api.models.the_full_details_of_the_case_to_be_replaced_required import TheFullDetailsOfTheCaseToBeReplacedRequired

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


class CaseApi:
    """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 bulk_assign_case(
        self,
        body: CdmBulkAssignCaseRequest,
        _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,
    ) -> CdmBulkAssignCaseResponse:
        """Bulk assign case owner and bulk add related users


        :param body: (required)
        :type body: CdmBulkAssignCaseRequest
        :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._bulk_assign_case_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmBulkAssignCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 bulk_assign_case_with_http_info(
        self,
        body: CdmBulkAssignCaseRequest,
        _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[CdmBulkAssignCaseResponse]:
        """Bulk assign case owner and bulk add related users


        :param body: (required)
        :type body: CdmBulkAssignCaseRequest
        :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._bulk_assign_case_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmBulkAssignCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 bulk_assign_case_without_preload_content(
        self,
        body: CdmBulkAssignCaseRequest,
        _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:
        """Bulk assign case owner and bulk add related users


        :param body: (required)
        :type body: CdmBulkAssignCaseRequest
        :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._bulk_assign_case_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmBulkAssignCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _bulk_assign_case_serialize(
        self,
        body,
        _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
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if body is not None:
            _body_params = body


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/assign',
            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 bulk_create_lead_cases(
        self,
        body: Annotated[CdmBulkCreateLeadCasesRequest, Field(description="Bulk create lead cases from completed cases.")],
        _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,
    ) -> CdmBulkCreateLeadCasesResponse:
        """Bulk create lead cases from complete cases.


        :param body: Bulk create lead cases from completed cases. (required)
        :type body: CdmBulkCreateLeadCasesRequest
        :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._bulk_create_lead_cases_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmBulkCreateLeadCasesResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 bulk_create_lead_cases_with_http_info(
        self,
        body: Annotated[CdmBulkCreateLeadCasesRequest, Field(description="Bulk create lead cases from completed cases.")],
        _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[CdmBulkCreateLeadCasesResponse]:
        """Bulk create lead cases from complete cases.


        :param body: Bulk create lead cases from completed cases. (required)
        :type body: CdmBulkCreateLeadCasesRequest
        :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._bulk_create_lead_cases_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmBulkCreateLeadCasesResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 bulk_create_lead_cases_without_preload_content(
        self,
        body: Annotated[CdmBulkCreateLeadCasesRequest, Field(description="Bulk create lead cases from completed cases.")],
        _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:
        """Bulk create lead cases from complete cases.


        :param body: Bulk create lead cases from completed cases. (required)
        :type body: CdmBulkCreateLeadCasesRequest
        :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._bulk_create_lead_cases_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmBulkCreateLeadCasesResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _bulk_create_lead_cases_serialize(
        self,
        body,
        _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
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if body is not None:
            _body_params = body


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/leads',
            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 create_case(
        self,
        body: Annotated[CdmCreateCaseRequest, Field(description="Create a new case.")],
        _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,
    ) -> CdmCreateCaseResponse:
        """Create a new case.


        :param body: Create a new case. (required)
        :type body: CdmCreateCaseRequest
        :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._create_case_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_with_http_info(
        self,
        body: Annotated[CdmCreateCaseRequest, Field(description="Create a new case.")],
        _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[CdmCreateCaseResponse]:
        """Create a new case.


        :param body: Create a new case. (required)
        :type body: CdmCreateCaseRequest
        :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._create_case_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_without_preload_content(
        self,
        body: Annotated[CdmCreateCaseRequest, Field(description="Create a new case.")],
        _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:
        """Create a new case.


        :param body: Create a new case. (required)
        :type body: CdmCreateCaseRequest
        :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._create_case_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_case_serialize(
        self,
        body,
        _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
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if body is not None:
            _body_params = body


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case',
            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 create_case_flag(
        self,
        flag_case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        flag: Annotated[MinimalDetailsOfFlagToAddRequired, Field(description="Minimal details of flag to add. Required.")],
        _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,
    ) -> CdmCreateCaseFlagResponse:
        """Create case flag.


        :param flag_case_id: Case ID. Required. (required)
        :type flag_case_id: str
        :param flag: Minimal details of flag to add. Required. (required)
        :type flag: MinimalDetailsOfFlagToAddRequired
        :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._create_case_flag_serialize(
            flag_case_id=flag_case_id,
            flag=flag,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseFlagResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_flag_with_http_info(
        self,
        flag_case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        flag: Annotated[MinimalDetailsOfFlagToAddRequired, Field(description="Minimal details of flag to add. Required.")],
        _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[CdmCreateCaseFlagResponse]:
        """Create case flag.


        :param flag_case_id: Case ID. Required. (required)
        :type flag_case_id: str
        :param flag: Minimal details of flag to add. Required. (required)
        :type flag: MinimalDetailsOfFlagToAddRequired
        :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._create_case_flag_serialize(
            flag_case_id=flag_case_id,
            flag=flag,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseFlagResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_flag_without_preload_content(
        self,
        flag_case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        flag: Annotated[MinimalDetailsOfFlagToAddRequired, Field(description="Minimal details of flag to add. Required.")],
        _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:
        """Create case flag.


        :param flag_case_id: Case ID. Required. (required)
        :type flag_case_id: str
        :param flag: Minimal details of flag to add. Required. (required)
        :type flag: MinimalDetailsOfFlagToAddRequired
        :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._create_case_flag_serialize(
            flag_case_id=flag_case_id,
            flag=flag,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseFlagResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_case_flag_serialize(
        self,
        flag_case_id,
        flag,
        _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 flag_case_id is not None:
            _path_params['flag.case_id'] = flag_case_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if flag is not None:
            _body_params = flag


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/{flag.case_id}/flag',
            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 create_case_flag_review(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        flag_id: Annotated[StrictStr, Field(description="Flag ID. Required.")],
        review: Annotated[CdmReviewBody, Field(description="Review body.")],
        _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,
    ) -> CdmCreateCaseFlagReviewResponse:
        """Create case flag review.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param flag_id: Flag ID. Required. (required)
        :type flag_id: str
        :param review: Review body. (required)
        :type review: CdmReviewBody
        :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._create_case_flag_review_serialize(
            case_id=case_id,
            flag_id=flag_id,
            review=review,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseFlagReviewResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_flag_review_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        flag_id: Annotated[StrictStr, Field(description="Flag ID. Required.")],
        review: Annotated[CdmReviewBody, Field(description="Review body.")],
        _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[CdmCreateCaseFlagReviewResponse]:
        """Create case flag review.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param flag_id: Flag ID. Required. (required)
        :type flag_id: str
        :param review: Review body. (required)
        :type review: CdmReviewBody
        :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._create_case_flag_review_serialize(
            case_id=case_id,
            flag_id=flag_id,
            review=review,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseFlagReviewResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_flag_review_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        flag_id: Annotated[StrictStr, Field(description="Flag ID. Required.")],
        review: Annotated[CdmReviewBody, Field(description="Review body.")],
        _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:
        """Create case flag review.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param flag_id: Flag ID. Required. (required)
        :type flag_id: str
        :param review: Review body. (required)
        :type review: CdmReviewBody
        :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._create_case_flag_review_serialize(
            case_id=case_id,
            flag_id=flag_id,
            review=review,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseFlagReviewResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_case_flag_review_serialize(
        self,
        case_id,
        flag_id,
        review,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        if flag_id is not None:
            _path_params['flag_id'] = flag_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if review is not None:
            _body_params = review


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/{case_id}/flag/{flag_id}/review',
            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 create_case_referral(
        self,
        body: Annotated[CdmCreateCaseReferralRequest, Field(description="Creates a new case from an existing case.")],
        _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,
    ) -> CdmCreateCaseResponse:
        """Create a new case from an existing one.


        :param body: Creates a new case from an existing case. (required)
        :type body: CdmCreateCaseReferralRequest
        :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._create_case_referral_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_referral_with_http_info(
        self,
        body: Annotated[CdmCreateCaseReferralRequest, Field(description="Creates a new case from an existing case.")],
        _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[CdmCreateCaseResponse]:
        """Create a new case from an existing one.


        :param body: Creates a new case from an existing case. (required)
        :type body: CdmCreateCaseReferralRequest
        :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._create_case_referral_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_referral_without_preload_content(
        self,
        body: Annotated[CdmCreateCaseReferralRequest, Field(description="Creates a new case from an existing case.")],
        _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:
        """Create a new case from an existing one.


        :param body: Creates a new case from an existing case. (required)
        :type body: CdmCreateCaseReferralRequest
        :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._create_case_referral_serialize(
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_case_referral_serialize(
        self,
        body,
        _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
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if body is not None:
            _body_params = body


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/referral',
            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 create_case_version(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        _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,
    ) -> CdmCreateCaseVersionResponse:
        """Create a case version.


        :param case_id: Case ID. Required. (required)
        :type case_id: 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._create_case_version_serialize(
            case_id=case_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_version_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        _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[CdmCreateCaseVersionResponse]:
        """Create a case version.


        :param case_id: Case ID. Required. (required)
        :type case_id: 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._create_case_version_serialize(
            case_id=case_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 create_case_version_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        _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:
        """Create a case version.


        :param case_id: Case ID. Required. (required)
        :type case_id: 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._create_case_version_serialize(
            case_id=case_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmCreateCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_case_version_serialize(
        self,
        case_id,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        # process the query parameters
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/{case_id}/version',
            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 describe_case_verification(
        self,
        _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,
    ) -> CdmDescribeCaseVerificationResponse:
        """Describe all installed verifications for cases.


        :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._describe_case_verification_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmDescribeCaseVerificationResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 describe_case_verification_with_http_info(
        self,
        _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[CdmDescribeCaseVerificationResponse]:
        """Describe all installed verifications for cases.


        :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._describe_case_verification_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmDescribeCaseVerificationResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 describe_case_verification_without_preload_content(
        self,
        _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:
        """Describe all installed verifications for cases.


        :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._describe_case_verification_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmDescribeCaseVerificationResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _describe_case_verification_serialize(
        self,
        _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
        # process the query parameters
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case/verification',
            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 get_case(
        self,
        case_details: Annotated[Optional[StrictBool], Field(description="Return the entire case details. By default this value is false, and only the IDs are returned.")] = None,
        case_ids: Annotated[Optional[List[StrictStr]], Field(description="Return cases by their IDs.")] = None,
        filter_client_ids: Annotated[Optional[List[StrictStr]], Field(description="Filter to only include cases with all (conjunction) of the specified clients assigned to them (including possibly other clients). Cannot be used with `case_ids` non-empty. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_owner_user_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are owned by the given user. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_owner_org_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are owned by a user in the given organisation. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_regulated_by_org_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are regulated_by the given organisation. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_ext_ids: Annotated[Optional[List[StrictStr]], Field(description="Only include cases with the specified case external IDs. This filter must be used in conjunction with filter_ext_source. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_ext_source: Annotated[Optional[StrictStr], Field(description="Filtering by external source. This filter must be used in conjunction with filter_ext_ids. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.   - ONFIDO: Onfido (https://onfido.com/).")] = None,
        filter_status: Annotated[Optional[List[StrictStr]], Field(description="Filter to only include cases with status equal to any of the given statuses (disjunction).  May only be supplied in conjunction with other filters. It is not possible to filter only on case status.")] = None,
        filter_order_reverse: Annotated[Optional[StrictBool], Field(description="Reverse the order of the filtered results.  Defaults to false.")] = None,
        bookmark: Annotated[Optional[StrictStr], Field(description="Opaque pagination bookmark. Set to the empty string (or omit) to begin.")] = None,
        page_size: Annotated[Optional[StrictInt], Field(description="Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.")] = None,
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for 0 will show all versions.")] = 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,
    ) -> CdmGetCaseResponse:
        """Get cases with their latest version.


        :param case_details: Return the entire case details. By default this value is false, and only the IDs are returned.
        :type case_details: bool
        :param case_ids: Return cases by their IDs.
        :type case_ids: List[str]
        :param filter_client_ids: Filter to only include cases with all (conjunction) of the specified clients assigned to them (including possibly other clients). Cannot be used with `case_ids` non-empty. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_client_ids: List[str]
        :param filter_owner_user_id: Filter to only include cases that are owned by the given user. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_owner_user_id: str
        :param filter_owner_org_id: Filter to only include cases that are owned by a user in the given organisation. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_owner_org_id: str
        :param filter_regulated_by_org_id: Filter to only include cases that are regulated_by the given organisation. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_regulated_by_org_id: str
        :param filter_ext_ids: Only include cases with the specified case external IDs. This filter must be used in conjunction with filter_ext_source. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_ext_ids: List[str]
        :param filter_ext_source: Filtering by external source. This filter must be used in conjunction with filter_ext_ids. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.   - ONFIDO: Onfido (https://onfido.com/).
        :type filter_ext_source: str
        :param filter_status: Filter to only include cases with status equal to any of the given statuses (disjunction).  May only be supplied in conjunction with other filters. It is not possible to filter only on case status.
        :type filter_status: List[str]
        :param filter_order_reverse: Reverse the order of the filtered results.  Defaults to false.
        :type filter_order_reverse: bool
        :param bookmark: Opaque pagination bookmark. Set to the empty string (or omit) to begin.
        :type bookmark: str
        :param page_size: Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.
        :type page_size: int
        :param show_history: Specify the number of previous versions to show change details for 0 will show all versions.
        :type show_history: int
        :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._get_case_serialize(
            case_details=case_details,
            case_ids=case_ids,
            filter_client_ids=filter_client_ids,
            filter_owner_user_id=filter_owner_user_id,
            filter_owner_org_id=filter_owner_org_id,
            filter_regulated_by_org_id=filter_regulated_by_org_id,
            filter_ext_ids=filter_ext_ids,
            filter_ext_source=filter_ext_source,
            filter_status=filter_status,
            filter_order_reverse=filter_order_reverse,
            bookmark=bookmark,
            page_size=page_size,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_with_http_info(
        self,
        case_details: Annotated[Optional[StrictBool], Field(description="Return the entire case details. By default this value is false, and only the IDs are returned.")] = None,
        case_ids: Annotated[Optional[List[StrictStr]], Field(description="Return cases by their IDs.")] = None,
        filter_client_ids: Annotated[Optional[List[StrictStr]], Field(description="Filter to only include cases with all (conjunction) of the specified clients assigned to them (including possibly other clients). Cannot be used with `case_ids` non-empty. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_owner_user_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are owned by the given user. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_owner_org_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are owned by a user in the given organisation. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_regulated_by_org_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are regulated_by the given organisation. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_ext_ids: Annotated[Optional[List[StrictStr]], Field(description="Only include cases with the specified case external IDs. This filter must be used in conjunction with filter_ext_source. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_ext_source: Annotated[Optional[StrictStr], Field(description="Filtering by external source. This filter must be used in conjunction with filter_ext_ids. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.   - ONFIDO: Onfido (https://onfido.com/).")] = None,
        filter_status: Annotated[Optional[List[StrictStr]], Field(description="Filter to only include cases with status equal to any of the given statuses (disjunction).  May only be supplied in conjunction with other filters. It is not possible to filter only on case status.")] = None,
        filter_order_reverse: Annotated[Optional[StrictBool], Field(description="Reverse the order of the filtered results.  Defaults to false.")] = None,
        bookmark: Annotated[Optional[StrictStr], Field(description="Opaque pagination bookmark. Set to the empty string (or omit) to begin.")] = None,
        page_size: Annotated[Optional[StrictInt], Field(description="Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.")] = None,
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for 0 will show all versions.")] = 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[CdmGetCaseResponse]:
        """Get cases with their latest version.


        :param case_details: Return the entire case details. By default this value is false, and only the IDs are returned.
        :type case_details: bool
        :param case_ids: Return cases by their IDs.
        :type case_ids: List[str]
        :param filter_client_ids: Filter to only include cases with all (conjunction) of the specified clients assigned to them (including possibly other clients). Cannot be used with `case_ids` non-empty. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_client_ids: List[str]
        :param filter_owner_user_id: Filter to only include cases that are owned by the given user. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_owner_user_id: str
        :param filter_owner_org_id: Filter to only include cases that are owned by a user in the given organisation. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_owner_org_id: str
        :param filter_regulated_by_org_id: Filter to only include cases that are regulated_by the given organisation. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_regulated_by_org_id: str
        :param filter_ext_ids: Only include cases with the specified case external IDs. This filter must be used in conjunction with filter_ext_source. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_ext_ids: List[str]
        :param filter_ext_source: Filtering by external source. This filter must be used in conjunction with filter_ext_ids. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.   - ONFIDO: Onfido (https://onfido.com/).
        :type filter_ext_source: str
        :param filter_status: Filter to only include cases with status equal to any of the given statuses (disjunction).  May only be supplied in conjunction with other filters. It is not possible to filter only on case status.
        :type filter_status: List[str]
        :param filter_order_reverse: Reverse the order of the filtered results.  Defaults to false.
        :type filter_order_reverse: bool
        :param bookmark: Opaque pagination bookmark. Set to the empty string (or omit) to begin.
        :type bookmark: str
        :param page_size: Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.
        :type page_size: int
        :param show_history: Specify the number of previous versions to show change details for 0 will show all versions.
        :type show_history: int
        :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._get_case_serialize(
            case_details=case_details,
            case_ids=case_ids,
            filter_client_ids=filter_client_ids,
            filter_owner_user_id=filter_owner_user_id,
            filter_owner_org_id=filter_owner_org_id,
            filter_regulated_by_org_id=filter_regulated_by_org_id,
            filter_ext_ids=filter_ext_ids,
            filter_ext_source=filter_ext_source,
            filter_status=filter_status,
            filter_order_reverse=filter_order_reverse,
            bookmark=bookmark,
            page_size=page_size,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_without_preload_content(
        self,
        case_details: Annotated[Optional[StrictBool], Field(description="Return the entire case details. By default this value is false, and only the IDs are returned.")] = None,
        case_ids: Annotated[Optional[List[StrictStr]], Field(description="Return cases by their IDs.")] = None,
        filter_client_ids: Annotated[Optional[List[StrictStr]], Field(description="Filter to only include cases with all (conjunction) of the specified clients assigned to them (including possibly other clients). Cannot be used with `case_ids` non-empty. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_owner_user_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are owned by the given user. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_owner_org_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are owned by a user in the given organisation. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_regulated_by_org_id: Annotated[Optional[StrictStr], Field(description="Filter to only include cases that are regulated_by the given organisation. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_ext_ids: Annotated[Optional[List[StrictStr]], Field(description="Only include cases with the specified case external IDs. This filter must be used in conjunction with filter_ext_source. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.")] = None,
        filter_ext_source: Annotated[Optional[StrictStr], Field(description="Filtering by external source. This filter must be used in conjunction with filter_ext_ids. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.   - ONFIDO: Onfido (https://onfido.com/).")] = None,
        filter_status: Annotated[Optional[List[StrictStr]], Field(description="Filter to only include cases with status equal to any of the given statuses (disjunction).  May only be supplied in conjunction with other filters. It is not possible to filter only on case status.")] = None,
        filter_order_reverse: Annotated[Optional[StrictBool], Field(description="Reverse the order of the filtered results.  Defaults to false.")] = None,
        bookmark: Annotated[Optional[StrictStr], Field(description="Opaque pagination bookmark. Set to the empty string (or omit) to begin.")] = None,
        page_size: Annotated[Optional[StrictInt], Field(description="Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.")] = None,
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for 0 will show all versions.")] = 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:
        """Get cases with their latest version.


        :param case_details: Return the entire case details. By default this value is false, and only the IDs are returned.
        :type case_details: bool
        :param case_ids: Return cases by their IDs.
        :type case_ids: List[str]
        :param filter_client_ids: Filter to only include cases with all (conjunction) of the specified clients assigned to them (including possibly other clients). Cannot be used with `case_ids` non-empty. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_client_ids: List[str]
        :param filter_owner_user_id: Filter to only include cases that are owned by the given user. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_owner_user_id: str
        :param filter_owner_org_id: Filter to only include cases that are owned by a user in the given organisation. Cannot be used with `case_ids`. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_owner_org_id: str
        :param filter_regulated_by_org_id: Filter to only include cases that are regulated_by the given organisation. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_regulated_by_org_id: str
        :param filter_ext_ids: Only include cases with the specified case external IDs. This filter must be used in conjunction with filter_ext_source. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.
        :type filter_ext_ids: List[str]
        :param filter_ext_source: Filtering by external source. This filter must be used in conjunction with filter_ext_ids. Cannot be used with case_ids. When multiple filters are specified, they all apply to return only results that match all the criteria.   - ONFIDO: Onfido (https://onfido.com/).
        :type filter_ext_source: str
        :param filter_status: Filter to only include cases with status equal to any of the given statuses (disjunction).  May only be supplied in conjunction with other filters. It is not possible to filter only on case status.
        :type filter_status: List[str]
        :param filter_order_reverse: Reverse the order of the filtered results.  Defaults to false.
        :type filter_order_reverse: bool
        :param bookmark: Opaque pagination bookmark. Set to the empty string (or omit) to begin.
        :type bookmark: str
        :param page_size: Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.
        :type page_size: int
        :param show_history: Specify the number of previous versions to show change details for 0 will show all versions.
        :type show_history: int
        :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._get_case_serialize(
            case_details=case_details,
            case_ids=case_ids,
            filter_client_ids=filter_client_ids,
            filter_owner_user_id=filter_owner_user_id,
            filter_owner_org_id=filter_owner_org_id,
            filter_regulated_by_org_id=filter_regulated_by_org_id,
            filter_ext_ids=filter_ext_ids,
            filter_ext_source=filter_ext_source,
            filter_status=filter_status,
            filter_order_reverse=filter_order_reverse,
            bookmark=bookmark,
            page_size=page_size,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_case_serialize(
        self,
        case_details,
        case_ids,
        filter_client_ids,
        filter_owner_user_id,
        filter_owner_org_id,
        filter_regulated_by_org_id,
        filter_ext_ids,
        filter_ext_source,
        filter_status,
        filter_order_reverse,
        bookmark,
        page_size,
        show_history,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'case_ids': 'multi',
            'filter_client_ids': 'multi',
            'filter_ext_ids': 'multi',
            'filter_status': '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
        # process the query parameters
        if case_details is not None:
            
            _query_params.append(('case_details', case_details))
            
        if case_ids is not None:
            
            _query_params.append(('case_ids', case_ids))
            
        if filter_client_ids is not None:
            
            _query_params.append(('filter_client_ids', filter_client_ids))
            
        if filter_owner_user_id is not None:
            
            _query_params.append(('filter_owner_user_id', filter_owner_user_id))
            
        if filter_owner_org_id is not None:
            
            _query_params.append(('filter_owner_org_id', filter_owner_org_id))
            
        if filter_regulated_by_org_id is not None:
            
            _query_params.append(('filter_regulated_by_org_id', filter_regulated_by_org_id))
            
        if filter_ext_ids is not None:
            
            _query_params.append(('filter_ext_ids', filter_ext_ids))
            
        if filter_ext_source is not None:
            
            _query_params.append(('filter_ext_source', filter_ext_source))
            
        if filter_status is not None:
            
            _query_params.append(('filter_status', filter_status))
            
        if filter_order_reverse is not None:
            
            _query_params.append(('filter_order_reverse', filter_order_reverse))
            
        if bookmark is not None:
            
            _query_params.append(('bookmark', bookmark))
            
        if page_size is not None:
            
            _query_params.append(('page_size', page_size))
            
        if show_history is not None:
            
            _query_params.append(('show_history', show_history))
            
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case',
            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 get_case_survey(
        self,
        case_id: Annotated[StrictStr, Field(description="case_id holds the uuidv4 of the case entity.")],
        _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,
    ) -> CdmGetCaseSurveyResponse:
        """Get case survey.


        :param case_id: case_id holds the uuidv4 of the case entity. (required)
        :type case_id: 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._get_case_survey_serialize(
            case_id=case_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseSurveyResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_survey_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="case_id holds the uuidv4 of the case entity.")],
        _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[CdmGetCaseSurveyResponse]:
        """Get case survey.


        :param case_id: case_id holds the uuidv4 of the case entity. (required)
        :type case_id: 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._get_case_survey_serialize(
            case_id=case_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseSurveyResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_survey_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="case_id holds the uuidv4 of the case entity.")],
        _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:
        """Get case survey.


        :param case_id: case_id holds the uuidv4 of the case entity. (required)
        :type case_id: 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._get_case_survey_serialize(
            case_id=case_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseSurveyResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_case_survey_serialize(
        self,
        case_id,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        # process the query parameters
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case/{case_id}/survey',
            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 get_case_verifications(
        self,
        case_id: Annotated[StrictStr, Field(description="ID of the case to retrieve verifications on. Required.")],
        version: Annotated[Optional[StrictInt], Field(description="Version of the case being verified (optional, uses latest when omitted, 0).")] = None,
        show_pass: Annotated[Optional[StrictBool], Field(description="By default only get failing verifications, set this to true to see passing verifications.")] = None,
        case_verifications: Annotated[Optional[StrictBool], Field(description="Whether to run case verifications. Defaults to true if neither case_verifications or document_requirements are provided.")] = None,
        document_requirements: Annotated[Optional[StrictBool], Field(description="Whether to run document requirements")] = 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,
    ) -> CdmGetCaseVerificationsResponse:
        """Retrieve verifications of an existing case.


        :param case_id: ID of the case to retrieve verifications on. Required. (required)
        :type case_id: str
        :param version: Version of the case being verified (optional, uses latest when omitted, 0).
        :type version: int
        :param show_pass: By default only get failing verifications, set this to true to see passing verifications.
        :type show_pass: bool
        :param case_verifications: Whether to run case verifications. Defaults to true if neither case_verifications or document_requirements are provided.
        :type case_verifications: bool
        :param document_requirements: Whether to run document requirements
        :type document_requirements: bool
        :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._get_case_verifications_serialize(
            case_id=case_id,
            version=version,
            show_pass=show_pass,
            case_verifications=case_verifications,
            document_requirements=document_requirements,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseVerificationsResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_verifications_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="ID of the case to retrieve verifications on. Required.")],
        version: Annotated[Optional[StrictInt], Field(description="Version of the case being verified (optional, uses latest when omitted, 0).")] = None,
        show_pass: Annotated[Optional[StrictBool], Field(description="By default only get failing verifications, set this to true to see passing verifications.")] = None,
        case_verifications: Annotated[Optional[StrictBool], Field(description="Whether to run case verifications. Defaults to true if neither case_verifications or document_requirements are provided.")] = None,
        document_requirements: Annotated[Optional[StrictBool], Field(description="Whether to run document requirements")] = 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[CdmGetCaseVerificationsResponse]:
        """Retrieve verifications of an existing case.


        :param case_id: ID of the case to retrieve verifications on. Required. (required)
        :type case_id: str
        :param version: Version of the case being verified (optional, uses latest when omitted, 0).
        :type version: int
        :param show_pass: By default only get failing verifications, set this to true to see passing verifications.
        :type show_pass: bool
        :param case_verifications: Whether to run case verifications. Defaults to true if neither case_verifications or document_requirements are provided.
        :type case_verifications: bool
        :param document_requirements: Whether to run document requirements
        :type document_requirements: bool
        :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._get_case_verifications_serialize(
            case_id=case_id,
            version=version,
            show_pass=show_pass,
            case_verifications=case_verifications,
            document_requirements=document_requirements,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseVerificationsResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_verifications_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="ID of the case to retrieve verifications on. Required.")],
        version: Annotated[Optional[StrictInt], Field(description="Version of the case being verified (optional, uses latest when omitted, 0).")] = None,
        show_pass: Annotated[Optional[StrictBool], Field(description="By default only get failing verifications, set this to true to see passing verifications.")] = None,
        case_verifications: Annotated[Optional[StrictBool], Field(description="Whether to run case verifications. Defaults to true if neither case_verifications or document_requirements are provided.")] = None,
        document_requirements: Annotated[Optional[StrictBool], Field(description="Whether to run document requirements")] = 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:
        """Retrieve verifications of an existing case.


        :param case_id: ID of the case to retrieve verifications on. Required. (required)
        :type case_id: str
        :param version: Version of the case being verified (optional, uses latest when omitted, 0).
        :type version: int
        :param show_pass: By default only get failing verifications, set this to true to see passing verifications.
        :type show_pass: bool
        :param case_verifications: Whether to run case verifications. Defaults to true if neither case_verifications or document_requirements are provided.
        :type case_verifications: bool
        :param document_requirements: Whether to run document requirements
        :type document_requirements: bool
        :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._get_case_verifications_serialize(
            case_id=case_id,
            version=version,
            show_pass=show_pass,
            case_verifications=case_verifications,
            document_requirements=document_requirements,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseVerificationsResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_case_verifications_serialize(
        self,
        case_id,
        version,
        show_pass,
        case_verifications,
        document_requirements,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        # process the query parameters
        if version is not None:
            
            _query_params.append(('version', version))
            
        if show_pass is not None:
            
            _query_params.append(('show_pass', show_pass))
            
        if case_verifications is not None:
            
            _query_params.append(('case_verifications', case_verifications))
            
        if document_requirements is not None:
            
            _query_params.append(('document_requirements', document_requirements))
            
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case/{case_id}/verifications',
            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 get_case_version(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        version: Annotated[StrictInt, Field(description="If zero, returns the latest (i.e., mutable) version. Required.")],
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for, 0 will show all versions.")] = 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,
    ) -> CdmGetCaseVersionResponse:
        """Get a case, specifying a version (use zero for latest).


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param version: If zero, returns the latest (i.e., mutable) version. Required. (required)
        :type version: int
        :param show_history: Specify the number of previous versions to show change details for, 0 will show all versions.
        :type show_history: int
        :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._get_case_version_serialize(
            case_id=case_id,
            version=version,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_version_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        version: Annotated[StrictInt, Field(description="If zero, returns the latest (i.e., mutable) version. Required.")],
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for, 0 will show all versions.")] = 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[CdmGetCaseVersionResponse]:
        """Get a case, specifying a version (use zero for latest).


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param version: If zero, returns the latest (i.e., mutable) version. Required. (required)
        :type version: int
        :param show_history: Specify the number of previous versions to show change details for, 0 will show all versions.
        :type show_history: int
        :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._get_case_version_serialize(
            case_id=case_id,
            version=version,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_case_version_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        version: Annotated[StrictInt, Field(description="If zero, returns the latest (i.e., mutable) version. Required.")],
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for, 0 will show all versions.")] = 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:
        """Get a case, specifying a version (use zero for latest).


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param version: If zero, returns the latest (i.e., mutable) version. Required. (required)
        :type version: int
        :param show_history: Specify the number of previous versions to show change details for, 0 will show all versions.
        :type show_history: int
        :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._get_case_version_serialize(
            case_id=case_id,
            version=version,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmGetCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_case_version_serialize(
        self,
        case_id,
        version,
        show_history,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        if version is not None:
            _path_params['version'] = version
        # process the query parameters
        if show_history is not None:
            
            _query_params.append(('show_history', show_history))
            
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case/{case_id}/version/{version}',
            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 get_hydrated_case(
        self,
        case_id: Annotated[StrictStr, Field(description="The case ID to retrieve.")],
        include_mortgages: Annotated[Optional[StrictBool], Field(description="Whether to include any mortgages in the response.")] = None,
        all_properties: Annotated[Optional[StrictBool], Field(description="Whether to include all properties the clients own or just those that are party to the transaction.")] = None,
        all_mortgages: Annotated[Optional[StrictBool], Field(description="Whether to include all mortgages for the clients or just those pertinent to the transaction.")] = None,
        include_donors: Annotated[Optional[StrictBool], Field(description="Whether to include donors in the response.")] = None,
        include_source_response: Annotated[Optional[StrictBool], Field(description="Whether to include source response in mortgages. Default false.")] = 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,
    ) -> CdmHydratedCaseResponse:
        """Get hydrated case.


        :param case_id: The case ID to retrieve. (required)
        :type case_id: str
        :param include_mortgages: Whether to include any mortgages in the response.
        :type include_mortgages: bool
        :param all_properties: Whether to include all properties the clients own or just those that are party to the transaction.
        :type all_properties: bool
        :param all_mortgages: Whether to include all mortgages for the clients or just those pertinent to the transaction.
        :type all_mortgages: bool
        :param include_donors: Whether to include donors in the response.
        :type include_donors: bool
        :param include_source_response: Whether to include source response in mortgages. Default false.
        :type include_source_response: bool
        :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._get_hydrated_case_serialize(
            case_id=case_id,
            include_mortgages=include_mortgages,
            all_properties=all_properties,
            all_mortgages=all_mortgages,
            include_donors=include_donors,
            include_source_response=include_source_response,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmHydratedCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_hydrated_case_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="The case ID to retrieve.")],
        include_mortgages: Annotated[Optional[StrictBool], Field(description="Whether to include any mortgages in the response.")] = None,
        all_properties: Annotated[Optional[StrictBool], Field(description="Whether to include all properties the clients own or just those that are party to the transaction.")] = None,
        all_mortgages: Annotated[Optional[StrictBool], Field(description="Whether to include all mortgages for the clients or just those pertinent to the transaction.")] = None,
        include_donors: Annotated[Optional[StrictBool], Field(description="Whether to include donors in the response.")] = None,
        include_source_response: Annotated[Optional[StrictBool], Field(description="Whether to include source response in mortgages. Default false.")] = 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[CdmHydratedCaseResponse]:
        """Get hydrated case.


        :param case_id: The case ID to retrieve. (required)
        :type case_id: str
        :param include_mortgages: Whether to include any mortgages in the response.
        :type include_mortgages: bool
        :param all_properties: Whether to include all properties the clients own or just those that are party to the transaction.
        :type all_properties: bool
        :param all_mortgages: Whether to include all mortgages for the clients or just those pertinent to the transaction.
        :type all_mortgages: bool
        :param include_donors: Whether to include donors in the response.
        :type include_donors: bool
        :param include_source_response: Whether to include source response in mortgages. Default false.
        :type include_source_response: bool
        :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._get_hydrated_case_serialize(
            case_id=case_id,
            include_mortgages=include_mortgages,
            all_properties=all_properties,
            all_mortgages=all_mortgages,
            include_donors=include_donors,
            include_source_response=include_source_response,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmHydratedCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 get_hydrated_case_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="The case ID to retrieve.")],
        include_mortgages: Annotated[Optional[StrictBool], Field(description="Whether to include any mortgages in the response.")] = None,
        all_properties: Annotated[Optional[StrictBool], Field(description="Whether to include all properties the clients own or just those that are party to the transaction.")] = None,
        all_mortgages: Annotated[Optional[StrictBool], Field(description="Whether to include all mortgages for the clients or just those pertinent to the transaction.")] = None,
        include_donors: Annotated[Optional[StrictBool], Field(description="Whether to include donors in the response.")] = None,
        include_source_response: Annotated[Optional[StrictBool], Field(description="Whether to include source response in mortgages. Default false.")] = 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:
        """Get hydrated case.


        :param case_id: The case ID to retrieve. (required)
        :type case_id: str
        :param include_mortgages: Whether to include any mortgages in the response.
        :type include_mortgages: bool
        :param all_properties: Whether to include all properties the clients own or just those that are party to the transaction.
        :type all_properties: bool
        :param all_mortgages: Whether to include all mortgages for the clients or just those pertinent to the transaction.
        :type all_mortgages: bool
        :param include_donors: Whether to include donors in the response.
        :type include_donors: bool
        :param include_source_response: Whether to include source response in mortgages. Default false.
        :type include_source_response: bool
        :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._get_hydrated_case_serialize(
            case_id=case_id,
            include_mortgages=include_mortgages,
            all_properties=all_properties,
            all_mortgages=all_mortgages,
            include_donors=include_donors,
            include_source_response=include_source_response,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmHydratedCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_hydrated_case_serialize(
        self,
        case_id,
        include_mortgages,
        all_properties,
        all_mortgages,
        include_donors,
        include_source_response,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        # process the query parameters
        if include_mortgages is not None:
            
            _query_params.append(('include_mortgages', include_mortgages))
            
        if all_properties is not None:
            
            _query_params.append(('all_properties', all_properties))
            
        if all_mortgages is not None:
            
            _query_params.append(('all_mortgages', all_mortgages))
            
        if include_donors is not None:
            
            _query_params.append(('include_donors', include_donors))
            
        if include_source_response is not None:
            
            _query_params.append(('include_source_response', include_source_response))
            
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case/{case_id}/hydrated',
            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 list_case_version(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        bookmark: Annotated[Optional[StrictStr], Field(description="Opaque pagination bookmark. Set to the empty string (or omit) to begin.")] = None,
        page_size: Annotated[Optional[StrictInt], Field(description="Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.")] = None,
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for, 0 will show all versions.")] = 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,
    ) -> CdmListCaseVersionResponse:
        """List case versions.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param bookmark: Opaque pagination bookmark. Set to the empty string (or omit) to begin.
        :type bookmark: str
        :param page_size: Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.
        :type page_size: int
        :param show_history: Specify the number of previous versions to show change details for, 0 will show all versions.
        :type show_history: int
        :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._list_case_version_serialize(
            case_id=case_id,
            bookmark=bookmark,
            page_size=page_size,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmListCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 list_case_version_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        bookmark: Annotated[Optional[StrictStr], Field(description="Opaque pagination bookmark. Set to the empty string (or omit) to begin.")] = None,
        page_size: Annotated[Optional[StrictInt], Field(description="Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.")] = None,
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for, 0 will show all versions.")] = 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[CdmListCaseVersionResponse]:
        """List case versions.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param bookmark: Opaque pagination bookmark. Set to the empty string (or omit) to begin.
        :type bookmark: str
        :param page_size: Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.
        :type page_size: int
        :param show_history: Specify the number of previous versions to show change details for, 0 will show all versions.
        :type show_history: int
        :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._list_case_version_serialize(
            case_id=case_id,
            bookmark=bookmark,
            page_size=page_size,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmListCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 list_case_version_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        bookmark: Annotated[Optional[StrictStr], Field(description="Opaque pagination bookmark. Set to the empty string (or omit) to begin.")] = None,
        page_size: Annotated[Optional[StrictInt], Field(description="Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.")] = None,
        show_history: Annotated[Optional[StrictInt], Field(description="Specify the number of previous versions to show change details for, 0 will show all versions.")] = 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:
        """List case versions.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param bookmark: Opaque pagination bookmark. Set to the empty string (or omit) to begin.
        :type bookmark: str
        :param page_size: Specify a limit on the number of items returned in a page. Values that are too large will be rejected. All requests are subject to the page size, which is 100 if not specified and can be specified up to 200.
        :type page_size: int
        :param show_history: Specify the number of previous versions to show change details for, 0 will show all versions.
        :type show_history: int
        :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._list_case_version_serialize(
            case_id=case_id,
            bookmark=bookmark,
            page_size=page_size,
            show_history=show_history,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmListCaseVersionResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _list_case_version_serialize(
        self,
        case_id,
        bookmark,
        page_size,
        show_history,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        # process the query parameters
        if bookmark is not None:
            
            _query_params.append(('bookmark', bookmark))
            
        if page_size is not None:
            
            _query_params.append(('page_size', page_size))
            
        if show_history is not None:
            
            _query_params.append(('show_history', show_history))
            
        # process the header parameters
        # 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'
                ]
            )


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

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/v1/acre/case/{case_id}/version',
            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 replace_case(
        self,
        case_case_id: Annotated[StrictStr, Field(description="Case reference. Populated automatically; cannot be set.")],
        case: Annotated[TheFullDetailsOfTheCaseToBeReplacedRequired, Field(description="The full details of the case to be replaced. Required.")],
        _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,
    ) -> CdmReplaceCaseResponse:
        """Replace (PUT) an existing case and current mutable version.


        :param case_case_id: Case reference. Populated automatically; cannot be set. (required)
        :type case_case_id: str
        :param case: The full details of the case to be replaced. Required. (required)
        :type case: TheFullDetailsOfTheCaseToBeReplacedRequired
        :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._replace_case_serialize(
            case_case_id=case_case_id,
            case=case,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmReplaceCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 replace_case_with_http_info(
        self,
        case_case_id: Annotated[StrictStr, Field(description="Case reference. Populated automatically; cannot be set.")],
        case: Annotated[TheFullDetailsOfTheCaseToBeReplacedRequired, Field(description="The full details of the case to be replaced. Required.")],
        _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[CdmReplaceCaseResponse]:
        """Replace (PUT) an existing case and current mutable version.


        :param case_case_id: Case reference. Populated automatically; cannot be set. (required)
        :type case_case_id: str
        :param case: The full details of the case to be replaced. Required. (required)
        :type case: TheFullDetailsOfTheCaseToBeReplacedRequired
        :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._replace_case_serialize(
            case_case_id=case_case_id,
            case=case,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmReplaceCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 replace_case_without_preload_content(
        self,
        case_case_id: Annotated[StrictStr, Field(description="Case reference. Populated automatically; cannot be set.")],
        case: Annotated[TheFullDetailsOfTheCaseToBeReplacedRequired, Field(description="The full details of the case to be replaced. Required.")],
        _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:
        """Replace (PUT) an existing case and current mutable version.


        :param case_case_id: Case reference. Populated automatically; cannot be set. (required)
        :type case_case_id: str
        :param case: The full details of the case to be replaced. Required. (required)
        :type case: TheFullDetailsOfTheCaseToBeReplacedRequired
        :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._replace_case_serialize(
            case_case_id=case_case_id,
            case=case,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmReplaceCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _replace_case_serialize(
        self,
        case_case_id,
        case,
        _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 case_case_id is not None:
            _path_params['case.case_id'] = case_case_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if case is not None:
            _body_params = case


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/v1/acre/case/{case.case_id}',
            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 update_case(
        self,
        case_case_id: Annotated[StrictStr, Field(description="Case reference. Populated automatically; cannot be set.")],
        case: Annotated[PartialDetailsOfTheCaseToBePatchedRequired, Field(description="Partial details of the case to be patched. Required.")],
        _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,
    ) -> CdmUpdateCaseResponse:
        """Update (PATCH) an existing case and current mutable version.


        :param case_case_id: Case reference. Populated automatically; cannot be set. (required)
        :type case_case_id: str
        :param case: Partial details of the case to be patched. Required. (required)
        :type case: PartialDetailsOfTheCaseToBePatchedRequired
        :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._update_case_serialize(
            case_case_id=case_case_id,
            case=case,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmUpdateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 update_case_with_http_info(
        self,
        case_case_id: Annotated[StrictStr, Field(description="Case reference. Populated automatically; cannot be set.")],
        case: Annotated[PartialDetailsOfTheCaseToBePatchedRequired, Field(description="Partial details of the case to be patched. Required.")],
        _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[CdmUpdateCaseResponse]:
        """Update (PATCH) an existing case and current mutable version.


        :param case_case_id: Case reference. Populated automatically; cannot be set. (required)
        :type case_case_id: str
        :param case: Partial details of the case to be patched. Required. (required)
        :type case: PartialDetailsOfTheCaseToBePatchedRequired
        :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._update_case_serialize(
            case_case_id=case_case_id,
            case=case,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmUpdateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 update_case_without_preload_content(
        self,
        case_case_id: Annotated[StrictStr, Field(description="Case reference. Populated automatically; cannot be set.")],
        case: Annotated[PartialDetailsOfTheCaseToBePatchedRequired, Field(description="Partial details of the case to be patched. Required.")],
        _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:
        """Update (PATCH) an existing case and current mutable version.


        :param case_case_id: Case reference. Populated automatically; cannot be set. (required)
        :type case_case_id: str
        :param case: Partial details of the case to be patched. Required. (required)
        :type case: PartialDetailsOfTheCaseToBePatchedRequired
        :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._update_case_serialize(
            case_case_id=case_case_id,
            case=case,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmUpdateCaseResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_case_serialize(
        self,
        case_case_id,
        case,
        _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 case_case_id is not None:
            _path_params['case.case_id'] = case_case_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if case is not None:
            _body_params = case


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='PATCH',
            resource_path='/v1/acre/case/{case.case_id}',
            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 update_case_status(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        body: AcreProcessorUpdateCaseStatusBody,
        _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,
    ) -> CdmUpdateCaseStatusResponse:
        """Update a case's status.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param body: (required)
        :type body: AcreProcessorUpdateCaseStatusBody
        :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._update_case_status_serialize(
            case_id=case_id,
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmUpdateCaseStatusResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 update_case_status_with_http_info(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        body: AcreProcessorUpdateCaseStatusBody,
        _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[CdmUpdateCaseStatusResponse]:
        """Update a case's status.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param body: (required)
        :type body: AcreProcessorUpdateCaseStatusBody
        :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._update_case_status_serialize(
            case_id=case_id,
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmUpdateCaseStatusResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        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 update_case_status_without_preload_content(
        self,
        case_id: Annotated[StrictStr, Field(description="Case ID. Required.")],
        body: AcreProcessorUpdateCaseStatusBody,
        _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:
        """Update a case's status.


        :param case_id: Case ID. Required. (required)
        :type case_id: str
        :param body: (required)
        :type body: AcreProcessorUpdateCaseStatusBody
        :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._update_case_status_serialize(
            case_id=case_id,
            body=body,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CdmUpdateCaseStatusResponse",
            '400': "V1ExceptionResponse",
            '401': "V1ExceptionResponse",
            '403': "V1ExceptionResponse",
            '404': "V1ExceptionResponse",
            '405': "str",
            '500': "V1ExceptionResponse",
            '503': "V1ExceptionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_case_status_serialize(
        self,
        case_id,
        body,
        _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 case_id is not None:
            _path_params['case_id'] = case_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if body is not None:
            _body_params = body


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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

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

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/v1/acre/case/{case_id}/case_transition',
            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
        )


